?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Move "questions and comments" at the top of the document.
[wine/multimedia.git] / files / file.c
blobb1a596127b8a08510e2c46f1a673ba8c44f42a59
1 /*
2 * File handling functions
3 *
4 * Copyright 1993 John Burton
5 * Copyright 1996 Alexandre Julliard
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * TODO:
22 * Fix the CopyFileEx methods to implement the "extended" functionality.
23 * Right now, they simply call the CopyFile method.
24 */
25
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <assert.h>
30 #include <ctype.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #ifdef HAVE_SYS_ERRNO_H
37 #include <sys/errno.h>
38 #endif
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #ifdef HAVE_SYS_MMAN_H
42 #include <sys/mman.h>
43 #endif
44 #include <sys/time.h>
45 #include <sys/poll.h>
46 #include <time.h>
47 #include <unistd.h>
48 #include <utime.h>
49
50 #include "winerror.h"
51 #include "windef.h"
52 #include "winbase.h"
53 #include "wine/winbase16.h"
54 #include "wine/server.h"
55
56 #include "drive.h"
57 #include "file.h"
58 #include "async.h"
59 #include "heap.h"
60 #include "msdos.h"
61 #include "wincon.h"
62
63 #include "smb.h"
64 #include "wine/debug.h"
65
66 WINE_DEFAULT_DEBUG_CHANNEL(file);
67
68 #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
69 #define MAP_ANON MAP_ANONYMOUS
70 #endif
71
72 /* Size of per-process table of DOS handles */
73 #define DOS_TABLE_SIZE 256
74
75 /* Macro to derive file offset from OVERLAPPED struct */
76 #define OVERLAPPED_OFFSET(overlapped) ((off_t) (overlapped)->Offset + ((off_t) (overlapped)->OffsetHigh << 32))
77
78 static HANDLE dos_handles[DOS_TABLE_SIZE];
79
80 mode_t FILE_umask;
81
82 extern HANDLE WINAPI FILE_SmbOpen(LPCSTR name);
83
84 /***********************************************************************
85 * Asynchronous file I/O *
86 */
87 static DWORD fileio_get_async_status (const async_private *ovp);
88 static DWORD fileio_get_async_count (const async_private *ovp);
89 static void fileio_set_async_status (async_private *ovp, const DWORD status);
90 static void CALLBACK fileio_call_completion_func (ULONG_PTR data);
91 static void fileio_async_cleanup (async_private *ovp);
92
93 static async_ops fileio_async_ops =
94 {
95 fileio_get_async_status, /* get_status */
96 fileio_set_async_status, /* set_status */
97 fileio_get_async_count, /* get_count */
98 fileio_call_completion_func, /* call_completion */
99 fileio_async_cleanup /* cleanup */
100 };
101
102 static async_ops fileio_nocomp_async_ops =
103 {
104 fileio_get_async_status, /* get_status */
105 fileio_set_async_status, /* set_status */
106 fileio_get_async_count, /* get_count */
107 NULL, /* call_completion */
108 fileio_async_cleanup /* cleanup */
109 };
110
111 typedef struct async_fileio
112 {
113 struct async_private async;
114 LPOVERLAPPED lpOverlapped;
115 LPOVERLAPPED_COMPLETION_ROUTINE completion_func;
116 char *buffer;
117 int count;
118 enum fd_type fd_type;
119 } async_fileio;
120
121 static DWORD fileio_get_async_status (const struct async_private *ovp)
122 {
123 return ((async_fileio*) ovp)->lpOverlapped->Internal;
124 }
125
126 static void fileio_set_async_status (async_private *ovp, const DWORD status)
127 {
128 ((async_fileio*) ovp)->lpOverlapped->Internal = status;
129 }
130
131 static DWORD fileio_get_async_count (const struct async_private *ovp)
132 {
133 async_fileio *fileio = (async_fileio*) ovp;
134 DWORD ret = fileio->count - fileio->lpOverlapped->InternalHigh;
135 return (ret < 0 ? 0 : ret);
136 }
137
138 static void CALLBACK fileio_call_completion_func (ULONG_PTR data)
139 {
140 async_fileio *ovp = (async_fileio*) data;
141 TRACE ("data: %p\n", ovp);
142
143 ovp->completion_func( ovp->lpOverlapped->Internal,
144 ovp->lpOverlapped->InternalHigh,
145 ovp->lpOverlapped );
146
147 fileio_async_cleanup ( &ovp->async );
148 }
149
150 static void fileio_async_cleanup ( struct async_private *ovp )
151 {
152 HeapFree ( GetProcessHeap(), 0, ovp );
153 }
154
155 /***********************************************************************
156 * FILE_ConvertOFMode
157 *
158 * Convert OF_* mode into flags for CreateFile.
159 */
160 static void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
161 {
162 switch(mode & 0x03)
163 {
164 case OF_READ: *access = GENERIC_READ; break;
165 case OF_WRITE: *access = GENERIC_WRITE; break;
166 case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
167 default: *access = 0; break;
168 }
169 switch(mode & 0x70)
170 {
171 case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
172 case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
173 case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
174 case OF_SHARE_DENY_NONE:
175 case OF_SHARE_COMPAT:
176 default: *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
177 }
178 }
179
180
181 /***********************************************************************
182 * FILE_strcasecmp
183 *
184 * locale-independent case conversion for file I/O
185 */
186 int FILE_strcasecmp( const char *str1, const char *str2 )
187 {
188 for (;;)
189 {
190 int ret = FILE_toupper(*str1) - FILE_toupper(*str2);
191 if (ret || !*str1) return ret;
192 str1++;
193 str2++;
194 }
195 }
196
197
198 /***********************************************************************
199 * FILE_strncasecmp
200 *
201 * locale-independent case conversion for file I/O
202 */
203 int FILE_strncasecmp( const char *str1, const char *str2, int len )
204 {
205 int ret = 0;
206 for ( ; len > 0; len--, str1++, str2++)
207 if ((ret = FILE_toupper(*str1) - FILE_toupper(*str2)) || !*str1) break;
208 return ret;
209 }
210
211
212 /***********************************************************************
213 * FILE_GetNtStatus(void)
214 *
215 * Retrieve the Nt Status code from errno.
216 * Try to be consistent with FILE_SetDosError().
217 */
218 DWORD FILE_GetNtStatus(void)
219 {
220 int err = errno;
221 DWORD nt;
222 TRACE ( "errno = %d\n", errno );
223 switch ( err )
224 {
225 case EAGAIN: nt = STATUS_SHARING_VIOLATION; break;
226 case EBADF: nt = STATUS_INVALID_HANDLE; break;
227 case ENOSPC: nt = STATUS_DISK_FULL; break;
228 case EPERM:
229 case EROFS:
230 case EACCES: nt = STATUS_ACCESS_DENIED; break;
231 case ENOENT: nt = STATUS_SHARING_VIOLATION; break;
232 case EISDIR: nt = STATUS_FILE_IS_A_DIRECTORY; break;
233 case EMFILE:
234 case ENFILE: nt = STATUS_NO_MORE_FILES; break;
235 case EINVAL:
236 case ENOTEMPTY: nt = STATUS_DIRECTORY_NOT_EMPTY; break;
237 case EPIPE: nt = STATUS_PIPE_BROKEN; break;
238 case ENOEXEC: /* ?? */
239 case ESPIPE: /* ?? */
240 case EEXIST: /* ?? */
241 default:
242 FIXME ( "Converting errno %d to STATUS_UNSUCCESSFUL\n", err );
243 nt = STATUS_UNSUCCESSFUL;
244 }
245 return nt;
246 }
247
248 /***********************************************************************
249 * FILE_SetDosError
250 *
251 * Set the DOS error code from errno.
252 */
253 void FILE_SetDosError(void)
254 {
255 int save_errno = errno; /* errno gets overwritten by printf */
256
257 TRACE("errno = %d %s\n", errno, strerror(errno));
258 switch (save_errno)
259 {
260 case EAGAIN:
261 SetLastError( ERROR_SHARING_VIOLATION );
262 break;
263 case EBADF:
264 SetLastError( ERROR_INVALID_HANDLE );
265 break;
266 case ENOSPC:
267 SetLastError( ERROR_HANDLE_DISK_FULL );
268 break;
269 case EACCES:
270 case EPERM:
271 case EROFS:
272 SetLastError( ERROR_ACCESS_DENIED );
273 break;
274 case EBUSY:
275 SetLastError( ERROR_LOCK_VIOLATION );
276 break;
277 case ENOENT:
278 SetLastError( ERROR_FILE_NOT_FOUND );
279 break;
280 case EISDIR:
281 SetLastError( ERROR_CANNOT_MAKE );
282 break;
283 case ENFILE:
284 case EMFILE:
285 SetLastError( ERROR_NO_MORE_FILES );
286 break;
287 case EEXIST:
288 SetLastError( ERROR_FILE_EXISTS );
289 break;
290 case EINVAL:
291 case ESPIPE:
292 SetLastError( ERROR_SEEK );
293 break;
294 case ENOTEMPTY:
295 SetLastError( ERROR_DIR_NOT_EMPTY );
296 break;
297 case ENOEXEC:
298 SetLastError( ERROR_BAD_FORMAT );
299 break;
300 default:
301 WARN("unknown file error: %s\n", strerror(save_errno) );
302 SetLastError( ERROR_GEN_FAILURE );
303 break;
304 }
305 errno = save_errno;
306 }
307
308
309 /***********************************************************************
310 * FILE_GetUnixHandleType
311 *
312 * Retrieve the Unix handle corresponding to a file handle.
313 * Returns -1 on failure.
314 */
315 static int FILE_GetUnixHandleType( HANDLE handle, DWORD access, enum fd_type *type, int *flags_ptr )
316 {
317 int ret, flags, fd = -1;
318
319 ret = wine_server_handle_to_fd( handle, access, &fd, type, &flags );
320 if (flags_ptr) *flags_ptr = flags;
321 if (ret) SetLastError( RtlNtStatusToDosError(ret) );
322 else if (((access & GENERIC_READ) && (flags & FD_FLAG_RECV_SHUTDOWN)) ||
323 ((access & GENERIC_WRITE) && (flags & FD_FLAG_SEND_SHUTDOWN)))
324 {
325 close (fd);
326 SetLastError ( ERROR_PIPE_NOT_CONNECTED );
327 return -1;
328 }
329 return fd;
330 }
331
332 /***********************************************************************
333 * FILE_GetUnixHandle
334 *
335 * Retrieve the Unix handle corresponding to a file handle.
336 * Returns -1 on failure.
337 */
338 int FILE_GetUnixHandle( HANDLE handle, DWORD access )
339 {
340 return FILE_GetUnixHandleType( handle, access, NULL, NULL );
341 }
342
343 /*************************************************************************
344 * FILE_OpenConsole
345 *
346 * Open a handle to the current process console.
347 * Returns 0 on failure.
348 */
349 static HANDLE FILE_OpenConsole( BOOL output, DWORD access, DWORD sharing, LPSECURITY_ATTRIBUTES sa )
350 {
351 HANDLE ret;
352
353 SERVER_START_REQ( open_console )
354 {
355 req->from = output;
356 req->access = access;
357 req->share = sharing;
358 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
359 SetLastError(0);
360 wine_server_call_err( req );
361 ret = reply->handle;
362 }
363 SERVER_END_REQ;
364 return ret;
365 }
366
367
368 /***********************************************************************
369 * FILE_CreateFile
370 *
371 * Implementation of CreateFile. Takes a Unix path name.
372 * Returns 0 on failure.
373 */
374 HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
375 LPSECURITY_ATTRIBUTES sa, DWORD creation,
376 DWORD attributes, HANDLE template, BOOL fail_read_only,
377 UINT drive_type )
378 {
379 unsigned int err;
380 HANDLE ret;
381
382 for (;;)
383 {
384 SERVER_START_REQ( create_file )
385 {
386 req->access = access;
387 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
388 req->sharing = sharing;
389 req->create = creation;
390 req->attrs = attributes;
391 req->drive_type = drive_type;
392 wine_server_add_data( req, filename, strlen(filename) );
393 SetLastError(0);
394 err = wine_server_call( req );
395 ret = reply->handle;
396 }
397 SERVER_END_REQ;
398
399 /* If write access failed, retry without GENERIC_WRITE */
400
401 if (!ret && !fail_read_only && (access & GENERIC_WRITE))
402 {
403 if ((err == STATUS_MEDIA_WRITE_PROTECTED) || (err == STATUS_ACCESS_DENIED))
404 {
405 TRACE("Write access failed for file '%s', trying without "
406 "write access\n", filename);
407 access &= ~GENERIC_WRITE;
408 continue;
409 }
410 }
411
412 if (err) SetLastError( RtlNtStatusToDosError(err) );
413
414 if (!ret) WARN("Unable to create file '%s' (GLE %ld)\n", filename, GetLastError());
415 return ret;
416 }
417 }
418
419
420 /***********************************************************************
421 * FILE_CreateDevice
422 *
423 * Same as FILE_CreateFile but for a device
424 * Returns 0 on failure.
425 */
426 HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
427 {
428 HANDLE ret;
429 SERVER_START_REQ( create_device )
430 {
431 req->access = access;
432 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
433 req->id = client_id;
434 SetLastError(0);
435 wine_server_call_err( req );
436 ret = reply->handle;
437 }
438 SERVER_END_REQ;
439 return ret;
440 }
441
442 static HANDLE FILE_OpenPipe(LPCSTR name, DWORD access)
443 {
444 WCHAR buffer[MAX_PATH];
445 HANDLE ret;
446 DWORD len = 0;
447
448 if (name && !(len = MultiByteToWideChar( CP_ACP, 0, name, strlen(name), buffer, MAX_PATH )))
449 {
450 SetLastError( ERROR_FILENAME_EXCED_RANGE );
451 return 0;
452 }
453 SERVER_START_REQ( open_named_pipe )
454 {
455 req->access = access;
456 SetLastError(0);
457 wine_server_add_data( req, buffer, len * sizeof(WCHAR) );
458 wine_server_call_err( req );
459 ret = reply->handle;
460 }
461 SERVER_END_REQ;
462 TRACE("Returned %d\n",ret);
463 return ret;
464 }
465
466 /*************************************************************************
467 * CreateFileA [KERNEL32.@] Creates or opens a file or other object
468 *
469 * Creates or opens an object, and returns a handle that can be used to
470 * access that object.
471 *
472 * PARAMS
473 *
474 * filename [in] pointer to filename to be accessed
475 * access [in] access mode requested
476 * sharing [in] share mode
477 * sa [in] pointer to security attributes
478 * creation [in] how to create the file
479 * attributes [in] attributes for newly created file
480 * template [in] handle to file with extended attributes to copy
481 *
482 * RETURNS
483 * Success: Open handle to specified file
484 * Failure: INVALID_HANDLE_VALUE
485 *
486 * NOTES
487 * Should call SetLastError() on failure.
488 *
489 * BUGS
490 *
491 * Doesn't support character devices, template files, or a
492 * lot of the 'attributes' flags yet.
493 */
494 HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
495 LPSECURITY_ATTRIBUTES sa, DWORD creation,
496 DWORD attributes, HANDLE template )
497 {
498 DOS_FULL_NAME full_name;
499 HANDLE ret;
500
501 if (!filename)
502 {
503 SetLastError( ERROR_INVALID_PARAMETER );
504 return INVALID_HANDLE_VALUE;
505 }
506 TRACE("%s %s%s%s%s%s%s%s\n",filename,
507 ((access & GENERIC_READ)==GENERIC_READ)?"GENERIC_READ ":"",
508 ((access & GENERIC_WRITE)==GENERIC_WRITE)?"GENERIC_WRITE ":"",
509 (!access)?"QUERY_ACCESS ":"",
510 ((sharing & FILE_SHARE_READ)==FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
511 ((sharing & FILE_SHARE_WRITE)==FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
512 ((sharing & FILE_SHARE_DELETE)==FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
513 (creation ==CREATE_NEW)?"CREATE_NEW":
514 (creation ==CREATE_ALWAYS)?"CREATE_ALWAYS ":
515 (creation ==OPEN_EXISTING)?"OPEN_EXISTING ":
516 (creation ==OPEN_ALWAYS)?"OPEN_ALWAYS ":
517 (creation ==TRUNCATE_EXISTING)?"TRUNCATE_EXISTING ":"");
518
519 /* If the name starts with '\\?\', ignore the first 4 chars. */
520 if (!strncmp(filename, "\\\\?\\", 4))
521 {
522 filename += 4;
523 if (!strncmp(filename, "UNC\\", 4))
524 {
525 FIXME("UNC name (%s) not supported.\n", filename );
526 SetLastError( ERROR_PATH_NOT_FOUND );
527 return INVALID_HANDLE_VALUE;
528 }
529 }
530
531 if (!strncmp(filename, "\\\\.\\", 4)) {
532 if(!strncasecmp(&filename[4],"pipe\\",5))
533 {
534 TRACE("Opening a pipe: %s\n",filename);
535 ret = FILE_OpenPipe(filename,access);
536 goto done;
537 }
538 else if (isalpha(filename[4]) && filename[5] == ':' && filename[6] == '\0')
539 {
540 ret = FILE_CreateDevice( (toupper(filename[4]) - 'A') | 0x20000, access, sa );
541 goto done;
542 }
543 else if (!DOSFS_GetDevice( filename ))
544 {
545 ret = DEVICE_Open( filename+4, access, sa );
546 goto done;
547 }
548 else
549 filename+=4; /* fall into DOSFS_Device case below */
550 }
551
552 /* If the name still starts with '\\', it's a UNC name. */
553 if (!strncmp(filename, "\\\\", 2))
554 {
555 ret = SMB_CreateFileA(filename, access, sharing, sa, creation, attributes, template );
556 goto done;
557 }
558
559 /* If the name contains a DOS wild card (* or ?), do no create a file */
560 if(strchr(filename,'*') || strchr(filename,'?'))
561 return INVALID_HANDLE_VALUE;
562
563 /* Open a console for CONIN$ or CONOUT$ */
564 if (!strcasecmp(filename, "CONIN$"))
565 {
566 ret = FILE_OpenConsole( FALSE, access, sharing, sa );
567 goto done;
568 }
569 if (!strcasecmp(filename, "CONOUT$"))
570 {
571 ret = FILE_OpenConsole( TRUE, access, sharing, sa );
572 goto done;
573 }
574
575 if (DOSFS_GetDevice( filename ))
576 {
577 TRACE("opening device '%s'\n", filename );
578
579 if (!(ret = DOSFS_OpenDevice( filename, access, attributes, sa )))
580 {
581 /* Do not silence this please. It is a critical error. -MM */
582 ERR("Couldn't open device '%s'!\n",filename);
583 SetLastError( ERROR_FILE_NOT_FOUND );
584 }
585 goto done;
586 }
587
588 /* check for filename, don't check for last entry if creating */
589 if (!DOSFS_GetFullName( filename,
590 (creation == OPEN_EXISTING) ||
591 (creation == TRUNCATE_EXISTING),
592 &full_name )) {
593 WARN("Unable to get full filename from '%s' (GLE %ld)\n",
594 filename, GetLastError());
595 return INVALID_HANDLE_VALUE;
596 }
597
598 ret = FILE_CreateFile( full_name.long_name, access, sharing,
599 sa, creation, attributes, template,
600 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY,
601 GetDriveTypeA( full_name.short_name ) );
602 done:
603 if (!ret) ret = INVALID_HANDLE_VALUE;
604 return ret;
605 }
606
607
608
609 /*************************************************************************
610 * CreateFileW (KERNEL32.@)
611 */
612 HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
613 LPSECURITY_ATTRIBUTES sa, DWORD creation,
614 DWORD attributes, HANDLE template)
615 {
616 LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
617 HANDLE res = CreateFileA( afn, access, sharing, sa, creation, attributes, template );
618 HeapFree( GetProcessHeap(), 0, afn );
619 return res;
620 }
621
622
623 /***********************************************************************
624 * FILE_FillInfo
625 *
626 * Fill a file information from a struct stat.
627 */
628 static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
629 {
630 if (S_ISDIR(st->st_mode))
631 info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
632 else
633 info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
634 if (!(st->st_mode & S_IWUSR))
635 info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
636
637 RtlSecondsSince1970ToTime( st->st_mtime, &info->ftCreationTime );
638 RtlSecondsSince1970ToTime( st->st_mtime, &info->ftLastWriteTime );
639 RtlSecondsSince1970ToTime( st->st_atime, &info->ftLastAccessTime );
640
641 info->dwVolumeSerialNumber = 0; /* FIXME */
642 info->nFileSizeHigh = 0;
643 info->nFileSizeLow = 0;
644 if (!S_ISDIR(st->st_mode)) {
645 info->nFileSizeHigh = st->st_size >> 32;
646 info->nFileSizeLow = st->st_size & 0xffffffff;
647 }
648 info->nNumberOfLinks = st->st_nlink;
649 info->nFileIndexHigh = 0;
650 info->nFileIndexLow = st->st_ino;
651 }
652
653
654 /***********************************************************************
655 * FILE_Stat
656 *
657 * Stat a Unix path name. Return TRUE if OK.
658 */
659 BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
660 {
661 struct stat st;
662
663 if (lstat( unixName, &st ) == -1)
664 {
665 FILE_SetDosError();
666 return FALSE;
667 }
668 if (!S_ISLNK(st.st_mode)) FILE_FillInfo( &st, info );
669 else
670 {
671 /* do a "real" stat to find out
672 about the type of the symlink destination */
673 if (stat( unixName, &st ) == -1)
674 {
675 FILE_SetDosError();
676 return FALSE;
677 }
678 FILE_FillInfo( &st, info );
679 info->dwFileAttributes |= FILE_ATTRIBUTE_SYMLINK;
680 }
681 return TRUE;
682 }
683
684
685 /***********************************************************************
686 * GetFileInformationByHandle (KERNEL32.@)
687 */
688 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
689 BY_HANDLE_FILE_INFORMATION *info )
690 {
691 DWORD ret;
692 if (!info) return 0;
693
694 SERVER_START_REQ( get_file_info )
695 {
696 req->handle = hFile;
697 if ((ret = !wine_server_call_err( req )))
698 {
699 /* FIXME: which file types are supported ?
700 * Serial ports (FILE_TYPE_CHAR) are not,
701 * and MSDN also says that pipes are not supported.
702 * FILE_TYPE_REMOTE seems to be supported according to
703 * MSDN q234741.txt */
704 if ((reply->type == FILE_TYPE_DISK) || (reply->type == FILE_TYPE_REMOTE))
705 {
706 RtlSecondsSince1970ToTime( reply->write_time, &info->ftCreationTime );
707 RtlSecondsSince1970ToTime( reply->write_time, &info->ftLastWriteTime );
708 RtlSecondsSince1970ToTime( reply->access_time, &info->ftLastAccessTime );
709 info->dwFileAttributes = reply->attr;
710 info->dwVolumeSerialNumber = reply->serial;
711 info->nFileSizeHigh = reply->size_high;
712 info->nFileSizeLow = reply->size_low;
713 info->nNumberOfLinks = reply->links;
714 info->nFileIndexHigh = reply->index_high;
715 info->nFileIndexLow = reply->index_low;
716 }
717 else
718 {
719 SetLastError(ERROR_NOT_SUPPORTED);
720 ret = 0;
721 }
722 }
723 }
724 SERVER_END_REQ;
725 return ret;
726 }
727
728
729 /**************************************************************************
730 * GetFileAttributes (KERNEL.420)
731 */
732 DWORD WINAPI GetFileAttributes16( LPCSTR name )
733 {
734 return GetFileAttributesA( name );
735 }
736
737
738 /**************************************************************************
739 * GetFileAttributesA (KERNEL32.@)
740 */
741 DWORD WINAPI GetFileAttributesA( LPCSTR name )
742 {
743 DOS_FULL_NAME full_name;
744 BY_HANDLE_FILE_INFORMATION info;
745
746 if (name == NULL)
747 {
748 SetLastError( ERROR_INVALID_PARAMETER );
749 return -1;
750 }
751 if (!DOSFS_GetFullName( name, TRUE, &full_name) )
752 return -1;
753 if (!FILE_Stat( full_name.long_name, &info )) return -1;
754 return info.dwFileAttributes;
755 }
756
757
758 /**************************************************************************
759 * GetFileAttributesW (KERNEL32.@)
760 */
761 DWORD WINAPI GetFileAttributesW( LPCWSTR name )
762 {
763 LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
764 DWORD res = GetFileAttributesA( nameA );
765 HeapFree( GetProcessHeap(), 0, nameA );
766 return res;
767 }
768
769
770 /**************************************************************************
771 * SetFileAttributes (KERNEL.421)
772 */
773 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
774 {
775 return SetFileAttributesA( lpFileName, attributes );
776 }
777
778
779 /**************************************************************************
780 * SetFileAttributesA (KERNEL32.@)
781 */
782 BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD attributes)
783 {
784 struct stat buf;
785 DOS_FULL_NAME full_name;
786
787 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
788 return FALSE;
789
790 TRACE("(%s,%lx)\n",lpFileName,attributes);
791 if(stat(full_name.long_name,&buf)==-1)
792 {
793 FILE_SetDosError();
794 return FALSE;
795 }
796 if (attributes & FILE_ATTRIBUTE_READONLY)
797 {
798 if(S_ISDIR(buf.st_mode))
799 /* FIXME */
800 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
801 else
802 buf.st_mode &= ~0222; /* octal!, clear write permission bits */
803 attributes &= ~FILE_ATTRIBUTE_READONLY;
804 }
805 else
806 {
807 /* add write permission */
808 buf.st_mode |= (0600 | ((buf.st_mode & 044) >> 1)) & (~FILE_umask);
809 }
810 if (attributes & FILE_ATTRIBUTE_DIRECTORY)
811 {
812 if (!S_ISDIR(buf.st_mode))
813 FIXME("SetFileAttributes expected the file '%s' to be a directory\n",
814 lpFileName);
815 attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
816 }
817 attributes &= ~(FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
818 if (attributes)
819 FIXME("(%s):%lx attribute(s) not implemented.\n", lpFileName,attributes);
820 if (-1==chmod(full_name.long_name,buf.st_mode))
821 {
822 if(GetDriveTypeA(lpFileName) == DRIVE_CDROM) {
823 SetLastError( ERROR_ACCESS_DENIED );
824 return FALSE;
825 }
826
827 /*
828 * FIXME: We don't return FALSE here because of differences between
829 * Linux and Windows privileges. Under Linux only the owner of
830 * the file is allowed to change file attributes. Under Windows,
831 * applications expect that if you can write to a file, you can also
832 * change its attributes (see GENERIC_WRITE). We could try to be
833 * clever here but that would break multi-user installations where
834 * users share read-only DLLs. This is because some installers like
835 * to change attributes of already installed DLLs.
836 */
837 FIXME("Couldn't set file attributes for existing file \"%s\".\n"
838 "Check permissions or set VFAT \"quiet\" mount flag\n", full_name.long_name);
839 }
840 return TRUE;
841 }
842
843
844 /**************************************************************************
845 * SetFileAttributesW (KERNEL32.@)
846 */
847 BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD attributes)
848 {
849 BOOL res;
850 DWORD len = WideCharToMultiByte( CP_ACP, 0, lpFileName, -1, NULL, 0, NULL, NULL );
851 LPSTR afn = HeapAlloc( GetProcessHeap(), 0, len );
852
853 WideCharToMultiByte( CP_ACP, 0, lpFileName, -1, afn, len, NULL, NULL );
854 res = SetFileAttributesA( afn, attributes );
855 HeapFree( GetProcessHeap(), 0, afn );
856 return res;
857 }
858
859
860 /***********************************************************************
861 * GetFileSize (KERNEL32.@)
862 */
863 DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD filesizehigh )
864 {
865 BY_HANDLE_FILE_INFORMATION info;
866 if (!GetFileInformationByHandle( hFile, &info )) return -1;
867 if (filesizehigh) *filesizehigh = info.nFileSizeHigh;
868 return info.nFileSizeLow;
869 }
870
871
872 /***********************************************************************
873 * GetFileTime (KERNEL32.@)
874 */
875 BOOL WINAPI GetFileTime( HANDLE hFile, FILETIME *lpCreationTime,
876 FILETIME *lpLastAccessTime,
877 FILETIME *lpLastWriteTime )
878 {
879 BY_HANDLE_FILE_INFORMATION info;
880 if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
881 if (lpCreationTime) *lpCreationTime = info.ftCreationTime;
882 if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
883 if (lpLastWriteTime) *lpLastWriteTime = info.ftLastWriteTime;
884 return TRUE;
885 }
886
887 /***********************************************************************
888 * CompareFileTime (KERNEL32.@)
889 */
890 INT WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
891 {
892 if (!x || !y) return -1;
893
894 if (x->dwHighDateTime > y->dwHighDateTime)
895 return 1;
896 if (x->dwHighDateTime < y->dwHighDateTime)
897 return -1;
898 if (x->dwLowDateTime > y->dwLowDateTime)
899 return 1;
900 if (x->dwLowDateTime < y->dwLowDateTime)
901 return -1;
902 return 0;
903 }
904
905 /***********************************************************************
906 * FILE_GetTempFileName : utility for GetTempFileName
907 */
908 static UINT FILE_GetTempFileName( LPCSTR path, LPCSTR prefix, UINT unique,
909 LPSTR buffer, BOOL isWin16 )
910 {
911 static UINT unique_temp;
912 DOS_FULL_NAME full_name;
913 int i;
914 LPSTR p;
915 UINT num;
916
917 if ( !path || !prefix || !buffer ) return 0;
918
919 if (!unique_temp) unique_temp = time(NULL) & 0xffff;
920 num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff);
921
922 strcpy( buffer, path );
923 p = buffer + strlen(buffer);
924
925 /* add a \, if there isn't one and path is more than just the drive letter ... */
926 if ( !((strlen(buffer) == 2) && (buffer[1] == ':'))
927 && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\';
928
929 if (isWin16) *p++ = '~';
930 for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
931 sprintf( p, "%04x.tmp", num );
932
933 /* Now try to create it */
934
935 if (!unique)
936 {
937 do
938 {
939 HFILE handle = CreateFileA( buffer, GENERIC_WRITE, 0, NULL,
940 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
941 if (handle != INVALID_HANDLE_VALUE)
942 { /* We created it */
943 TRACE("created %s\n",
944 buffer);
945 CloseHandle( handle );
946 break;
947 }
948 if (GetLastError() != ERROR_FILE_EXISTS)
949 break; /* No need to go on */
950 num++;
951 sprintf( p, "%04x.tmp", num );
952 } while (num != (unique & 0xffff));
953 }
954
955 /* Get the full path name */
956
957 if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
958 {
959 /* Check if we have write access in the directory */
960 if ((p = strrchr( full_name.long_name, '/' ))) *p = '\0';
961 if (access( full_name.long_name, W_OK ) == -1)
962 WARN("returns '%s', which doesn't seem to be writeable.\n",
963 buffer);
964 }
965 TRACE("returning %s\n", buffer );
966 return unique ? unique : num;
967 }
968
969
970 /***********************************************************************
971 * GetTempFileNameA (KERNEL32.@)
972 */
973 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
974 LPSTR buffer)
975 {
976 return FILE_GetTempFileName(path, prefix, unique, buffer, FALSE);
977 }
978
979 /***********************************************************************
980 * GetTempFileNameW (KERNEL32.@)
981 */
982 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
983 LPWSTR buffer )
984 {
985 LPSTR patha,prefixa;
986 char buffera[144];
987 UINT ret;
988
989 if (!path) return 0;
990 patha = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
991 prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
992 ret = FILE_GetTempFileName( patha, prefixa, unique, buffera, FALSE );
993 MultiByteToWideChar( CP_ACP, 0, buffera, -1, buffer, MAX_PATH );
994 HeapFree( GetProcessHeap(), 0, patha );
995 HeapFree( GetProcessHeap(), 0, prefixa );
996 return ret;
997 }
998
999
1000 /***********************************************************************
1001 * GetTempFileName (KERNEL.97)
1002 */
1003 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
1004 LPSTR buffer )
1005 {
1006 char temppath[144];
1007
1008 if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
1009 drive |= DRIVE_GetCurrentDrive() + 'A';
1010
1011 if ((drive & TF_FORCEDRIVE) &&
1012 !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
1013 {
1014 drive &= ~TF_FORCEDRIVE;
1015 WARN("invalid drive %d specified\n", drive );
1016 }
1017
1018 if (drive & TF_FORCEDRIVE)
1019 sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
1020 else
1021 GetTempPathA( 132, temppath );
1022 return (UINT16)FILE_GetTempFileName( temppath, prefix, unique, buffer, TRUE );
1023 }
1024
1025 /***********************************************************************
1026 * FILE_DoOpenFile
1027 *
1028 * Implementation of OpenFile16() and OpenFile32().
1029 */
1030 static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode,
1031 BOOL win32 )
1032 {
1033 HFILE hFileRet;
1034 FILETIME filetime;
1035 WORD filedatetime[2];
1036 DOS_FULL_NAME full_name;
1037 DWORD access, sharing;
1038 char *p;
1039
1040 if (!ofs) return HFILE_ERROR;
1041
1042 TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",name,
1043 ((mode & 0x3 )==OF_READ)?"OF_READ":
1044 ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
1045 ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
1046 ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
1047 ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
1048 ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
1049 ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
1050 ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
1051 ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
1052 ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
1053 ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
1054 ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
1055 ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
1056 ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
1057 ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
1058 ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
1059 ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
1060 );
1061
1062
1063 ofs->cBytes = sizeof(OFSTRUCT);
1064 ofs->nErrCode = 0;
1065 if (mode & OF_REOPEN) name = ofs->szPathName;
1066
1067 if (!name) {
1068 ERR("called with `name' set to NULL ! Please debug.\n");
1069 return HFILE_ERROR;
1070 }
1071
1072 TRACE("%s %04x\n", name, mode );
1073
1074 /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
1075 Are there any cases where getting the path here is wrong?
1076 Uwe Bonnes 1997 Apr 2 */
1077 if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
1078 ofs->szPathName, NULL )) goto error;
1079 FILE_ConvertOFMode( mode, &access, &sharing );
1080
1081 /* OF_PARSE simply fills the structure */
1082
1083 if (mode & OF_PARSE)
1084 {
1085 ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
1086 != DRIVE_REMOVABLE);
1087 TRACE("(%s): OF_PARSE, res = '%s'\n",
1088 name, ofs->szPathName );
1089 return 0;
1090 }
1091
1092 /* OF_CREATE is completely different from all other options, so
1093 handle it first */
1094
1095 if (mode & OF_CREATE)
1096 {
1097 if ((hFileRet = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
1098 sharing, NULL, CREATE_ALWAYS,
1099 FILE_ATTRIBUTE_NORMAL, 0 ))== INVALID_HANDLE_VALUE)
1100 goto error;
1101 goto success;
1102 }
1103
1104 /* If OF_SEARCH is set, ignore the given path */
1105
1106 if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
1107 {
1108 /* First try the file name as is */
1109 if (DOSFS_GetFullName( name, TRUE, &full_name )) goto found;
1110 /* Now remove the path */
1111 if (name[0] && (name[1] == ':')) name += 2;
1112 if ((p = strrchr( name, '\\' ))) name = p + 1;
1113 if ((p = strrchr( name, '/' ))) name = p + 1;
1114 if (!name[0]) goto not_found;
1115 }
1116
1117 /* Now look for the file */
1118
1119 if (!DIR_SearchPath( NULL, name, NULL, &full_name, win32 )) goto not_found;
1120
1121 found:
1122 TRACE("found %s = %s\n",
1123 full_name.long_name, full_name.short_name );
1124 lstrcpynA( ofs->szPathName, full_name.short_name,
1125 sizeof(ofs->szPathName) );
1126
1127 if (mode & OF_SHARE_EXCLUSIVE)
1128 /* Some InstallShield version uses OF_SHARE_EXCLUSIVE
1129 on the file <tempdir>/_ins0432._mp to determine how
1130 far installation has proceeded.
1131 _ins0432._mp is an executable and while running the
1132 application expects the open with OF_SHARE_ to fail*/
1133 /* Probable FIXME:
1134 As our loader closes the files after loading the executable,
1135 we can't find the running executable with FILE_InUse.
1136 The loader should keep the file open, as Windows does that, too.
1137 */
1138 {
1139 char *last = strrchr(full_name.long_name,'/');
1140 if (!last)
1141 last = full_name.long_name - 1;
1142 if (GetModuleHandle16(last+1))
1143 {
1144 TRACE("Denying shared open for %s\n",full_name.long_name);
1145 return HFILE_ERROR;
1146 }
1147 }
1148
1149 if (mode & OF_DELETE)
1150 {
1151 if (unlink( full_name.long_name ) == -1) goto not_found;
1152 TRACE("(%s): OF_DELETE return = OK\n", name);
1153 return 1;
1154 }
1155
1156 hFileRet = FILE_CreateFile( full_name.long_name, access, sharing,
1157 NULL, OPEN_EXISTING, 0, 0,
1158 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY,
1159 GetDriveTypeA( full_name.short_name ) );
1160 if (!hFileRet) goto not_found;
1161
1162 GetFileTime( hFileRet, NULL, NULL, &filetime );
1163 FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
1164 if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
1165 {
1166 if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
1167 {
1168 CloseHandle( hFileRet );
1169 WARN("(%s): OF_VERIFY failed\n", name );
1170 /* FIXME: what error here? */
1171 SetLastError( ERROR_FILE_NOT_FOUND );
1172 goto error;
1173 }
1174 }
1175 memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
1176
1177 success: /* We get here if the open was successful */
1178 TRACE("(%s): OK, return = %d\n", name, hFileRet );
1179 if (win32)
1180 {
1181 if (mode & OF_EXIST) /* Return the handle, but close it first */
1182 CloseHandle( hFileRet );
1183 }
1184 else
1185 {
1186 hFileRet = Win32HandleToDosFileHandle( hFileRet );
1187 if (hFileRet == HFILE_ERROR16) goto error;
1188 if (mode & OF_EXIST) /* Return the handle, but close it first */
1189 _lclose16( hFileRet );
1190 }
1191 return hFileRet;
1192
1193 not_found: /* We get here if the file does not exist */
1194 WARN("'%s' not found or sharing violation\n", name );
1195 SetLastError( ERROR_FILE_NOT_FOUND );
1196 /* fall through */
1197
1198 error: /* We get here if there was an error opening the file */
1199 ofs->nErrCode = GetLastError();
1200 WARN("(%s): return = HFILE_ERROR error= %d\n",
1201 name,ofs->nErrCode );
1202 return HFILE_ERROR;
1203 }
1204
1205
1206 /***********************************************************************
1207 * OpenFile (KERNEL.74)
1208 * OpenFileEx (KERNEL.360)
1209 */
1210 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
1211 {
1212 return FILE_DoOpenFile( name, ofs, mode, FALSE );
1213 }
1214
1215
1216 /***********************************************************************
1217 * OpenFile (KERNEL32.@)
1218 */
1219 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
1220 {
1221 return FILE_DoOpenFile( name, ofs, mode, TRUE );
1222 }
1223
1224
1225 /***********************************************************************
1226 * FILE_InitProcessDosHandles
1227 *
1228 * Allocates the default DOS handles for a process. Called either by
1229 * Win32HandleToDosFileHandle below or by the DOSVM stuff.
1230 */
1231 static void FILE_InitProcessDosHandles( void )
1232 {
1233 dos_handles[0] = GetStdHandle(STD_INPUT_HANDLE);
1234 dos_handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
1235 dos_handles[2] = GetStdHandle(STD_ERROR_HANDLE);
1236 dos_handles[3] = GetStdHandle(STD_ERROR_HANDLE);
1237 dos_handles[4] = GetStdHandle(STD_ERROR_HANDLE);
1238 }
1239
1240 /***********************************************************************
1241 * Win32HandleToDosFileHandle (KERNEL32.21)
1242 *
1243 * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
1244 * longer valid after this function (even on failure).
1245 *
1246 * Note: this is not exactly right, since on Win95 the Win32 handles
1247 * are on top of DOS handles and we do it the other way
1248 * around. Should be good enough though.
1249 */
1250 HFILE WINAPI Win32HandleToDosFileHandle( HANDLE handle )
1251 {
1252 int i;
1253
1254 if (!handle || (handle == INVALID_HANDLE_VALUE))
1255 return HFILE_ERROR;
1256
1257 for (i = 5; i < DOS_TABLE_SIZE; i++)
1258 if (!dos_handles[i])
1259 {
1260 dos_handles[i] = handle;
1261 TRACE("Got %d for h32 %d\n", i, handle );
1262 return (HFILE)i;
1263 }
1264 CloseHandle( handle );
1265 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1266 return HFILE_ERROR;
1267 }
1268
1269
1270 /***********************************************************************
1271 * DosFileHandleToWin32Handle (KERNEL32.20)
1272 *
1273 * Return the Win32 handle for a DOS handle.
1274 *
1275 * Note: this is not exactly right, since on Win95 the Win32 handles
1276 * are on top of DOS handles and we do it the other way
1277 * around. Should be good enough though.
1278 */
1279 HANDLE WINAPI DosFileHandleToWin32Handle( HFILE handle )
1280 {
1281 HFILE16 hfile = (HFILE16)handle;
1282 if (hfile < 5 && !dos_handles[hfile]) FILE_InitProcessDosHandles();
1283 if ((hfile >= DOS_TABLE_SIZE) || !dos_handles[hfile])
1284 {
1285 SetLastError( ERROR_INVALID_HANDLE );
1286 return INVALID_HANDLE_VALUE;
1287 }
1288 return dos_handles[hfile];
1289 }
1290
1291
1292 /***********************************************************************
1293 * DisposeLZ32Handle (KERNEL32.22)
1294 *
1295 * Note: this is not entirely correct, we should only close the
1296 * 32-bit handle and not the 16-bit one, but we cannot do
1297 * this because of the way our DOS handles are implemented.
1298 * It shouldn't break anything though.
1299 */
1300 void WINAPI DisposeLZ32Handle( HANDLE handle )
1301 {
1302 int i;
1303
1304 if (!handle || (handle == INVALID_HANDLE_VALUE)) return;
1305
1306 for (i = 5; i < DOS_TABLE_SIZE; i++)
1307 if (dos_handles[i] == handle)
1308 {
1309 dos_handles[i] = 0;
1310 CloseHandle( handle );
1311 break;
1312 }
1313 }
1314
1315
1316 /***********************************************************************
1317 * FILE_Dup2
1318 *
1319 * dup2() function for DOS handles.
1320 */
1321 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1322 {
1323 HANDLE new_handle;
1324
1325 if (hFile1 < 5 && !dos_handles[hFile1]) FILE_InitProcessDosHandles();
1326
1327 if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) || !dos_handles[hFile1])
1328 {
1329 SetLastError( ERROR_INVALID_HANDLE );
1330 return HFILE_ERROR16;
1331 }
1332 if (hFile2 < 5)
1333 {
1334 FIXME("stdio handle closed, need proper conversion\n" );
1335 SetLastError( ERROR_INVALID_HANDLE );
1336 return HFILE_ERROR16;
1337 }
1338 if (!DuplicateHandle( GetCurrentProcess(), dos_handles[hFile1],
1339 GetCurrentProcess(), &new_handle,
1340 0, FALSE, DUPLICATE_SAME_ACCESS ))
1341 return HFILE_ERROR16;
1342 if (dos_handles[hFile2]) CloseHandle( dos_handles[hFile2] );
1343 dos_handles[hFile2] = new_handle;
1344 return hFile2;
1345 }
1346
1347
1348 /***********************************************************************
1349 * _lclose (KERNEL.81)
1350 */
1351 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1352 {
1353 if (hFile < 5)
1354 {
1355 FIXME("stdio handle closed, need proper conversion\n" );
1356 SetLastError( ERROR_INVALID_HANDLE );
1357 return HFILE_ERROR16;
1358 }
1359 if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
1360 {
1361 SetLastError( ERROR_INVALID_HANDLE );
1362 return HFILE_ERROR16;
1363 }
1364 TRACE("%d (handle32=%d)\n", hFile, dos_handles[hFile] );
1365 CloseHandle( dos_handles[hFile] );
1366 dos_handles[hFile] = 0;
1367 return 0;
1368 }
1369
1370
1371 /***********************************************************************
1372 * _lclose (KERNEL32.@)
1373 */
1374 HFILE WINAPI _lclose( HFILE hFile )
1375 {
1376 TRACE("handle %d\n", hFile );
1377 return CloseHandle( hFile ) ? 0 : HFILE_ERROR;
1378 }
1379
1380 /***********************************************************************
1381 * GetOverlappedResult (KERNEL32.@)
1382 *
1383 * Check the result of an Asynchronous data transfer from a file.
1384 *
1385 * RETURNS
1386 * TRUE on success
1387 * FALSE on failure
1388 *
1389 * If successful (and relevant) lpTransferred will hold the number of
1390 * bytes transferred during the async operation.
1391 *
1392 * BUGS
1393 *
1394 * Currently only works for WaitCommEvent, ReadFile, WriteFile
1395 * with communications ports.
1396 *
1397 */
1398 BOOL WINAPI GetOverlappedResult(
1399 HANDLE hFile, /* [in] handle of file to check on */
1400 LPOVERLAPPED lpOverlapped, /* [in/out] pointer to overlapped */
1401 LPDWORD lpTransferred, /* [in/out] number of bytes transferred */
1402 BOOL bWait /* [in] wait for the transfer to complete ? */
1403 ) {
1404 DWORD r;
1405
1406 TRACE("(%d %p %p %x)\n", hFile, lpOverlapped, lpTransferred, bWait);
1407
1408 if(lpOverlapped==NULL)
1409 {
1410 ERR("lpOverlapped was null\n");
1411 return FALSE;
1412 }
1413 if(!lpOverlapped->hEvent)
1414 {
1415 ERR("lpOverlapped->hEvent was null\n");
1416 return FALSE;
1417 }
1418
1419 do {
1420 TRACE("waiting on %p\n",lpOverlapped);
1421 r = WaitForSingleObjectEx(lpOverlapped->hEvent, bWait?INFINITE:0, TRUE);
1422 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1423 } while (r==STATUS_USER_APC);
1424
1425 if(lpTransferred)
1426 *lpTransferred = lpOverlapped->InternalHigh;
1427
1428 SetLastError ( lpOverlapped->Internal == STATUS_PENDING ?
1429 ERROR_IO_INCOMPLETE : RtlNtStatusToDosError ( lpOverlapped->Internal ) );
1430
1431 return (r==WAIT_OBJECT_0);
1432 }
1433
1434 /***********************************************************************
1435 * CancelIo (KERNEL32.@)
1436 */
1437 BOOL WINAPI CancelIo(HANDLE handle)
1438 {
1439 async_private *ovp,*t;
1440
1441 TRACE("handle = %x\n",handle);
1442
1443 for (ovp = NtCurrentTeb()->pending_list; ovp; ovp = t)
1444 {
1445 t = ovp->next;
1446 if ( ovp->handle == handle )
1447 cancel_async ( ovp );
1448 }
1449 WaitForMultipleObjectsEx(0,NULL,FALSE,1,TRUE);
1450 return TRUE;
1451 }
1452
1453 /***********************************************************************
1454 * FILE_AsyncReadService (INTERNAL)
1455 *
1456 * This function is called while the client is waiting on the
1457 * server, so we can't make any server calls here.
1458 */
1459 static void FILE_AsyncReadService(async_private *ovp)
1460 {
1461 async_fileio *fileio = (async_fileio*) ovp;
1462 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1463 int result, r;
1464 int already = lpOverlapped->InternalHigh;
1465
1466 TRACE("%p %p\n", lpOverlapped, fileio->buffer );
1467
1468 /* check to see if the data is ready (non-blocking) */
1469
1470 if ( fileio->fd_type == FD_TYPE_SOCKET )
1471 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1472 else
1473 {
1474 result = pread (ovp->fd, &fileio->buffer[already], fileio->count - already,
1475 OVERLAPPED_OFFSET (lpOverlapped) + already);
1476 if ((result < 0) && (errno == ESPIPE))
1477 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1478 }
1479
1480 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1481 {
1482 TRACE("Deferred read %d\n",errno);
1483 r = STATUS_PENDING;
1484 goto async_end;
1485 }
1486
1487 /* check to see if the transfer is complete */
1488 if(result<0)
1489 {
1490 r = FILE_GetNtStatus ();
1491 goto async_end;
1492 }
1493
1494 lpOverlapped->InternalHigh += result;
1495 TRACE("read %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1496
1497 if(lpOverlapped->InternalHigh >= fileio->count || fileio->fd_type == FD_TYPE_SOCKET )
1498 r = STATUS_SUCCESS;
1499 else
1500 r = STATUS_PENDING;
1501
1502 async_end:
1503 lpOverlapped->Internal = r;
1504 }
1505
1506 /***********************************************************************
1507 * FILE_ReadFileEx (INTERNAL)
1508 */
1509 static BOOL FILE_ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1510 LPOVERLAPPED overlapped,
1511 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1512 HANDLE hEvent)
1513 {
1514 async_fileio *ovp;
1515 int fd;
1516 int flags;
1517 enum fd_type type;
1518
1519 TRACE("file %d to buf %p num %ld %p func %p\n",
1520 hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine);
1521
1522 /* check that there is an overlapped struct */
1523 if (overlapped==NULL)
1524 {
1525 SetLastError(ERROR_INVALID_PARAMETER);
1526 return FALSE;
1527 }
1528
1529 fd = FILE_GetUnixHandleType ( hFile, GENERIC_READ, &type, &flags);
1530 if ( fd < 0 )
1531 {
1532 WARN ( "Couldn't get FD\n" );
1533 return FALSE;
1534 }
1535
1536 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1537 if(!ovp)
1538 {
1539 TRACE("HeapAlloc Failed\n");
1540 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1541 goto error;
1542 }
1543
1544 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1545 ovp->async.handle = hFile;
1546 ovp->async.fd = fd;
1547 ovp->async.type = ASYNC_TYPE_READ;
1548 ovp->async.func = FILE_AsyncReadService;
1549 ovp->async.event = hEvent;
1550 ovp->lpOverlapped = overlapped;
1551 ovp->count = bytesToRead;
1552 ovp->completion_func = lpCompletionRoutine;
1553 ovp->buffer = buffer;
1554 ovp->fd_type = type;
1555
1556 return !register_new_async (&ovp->async);
1557
1558 error:
1559 close (fd);
1560 return FALSE;
1561
1562 }
1563
1564 /***********************************************************************
1565 * ReadFileEx (KERNEL32.@)
1566 */
1567 BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1568 LPOVERLAPPED overlapped,
1569 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1570 {
1571 overlapped->InternalHigh = 0;
1572 return FILE_ReadFileEx(hFile,buffer,bytesToRead,overlapped,lpCompletionRoutine, INVALID_HANDLE_VALUE);
1573 }
1574
1575 static BOOL FILE_TimeoutRead(HANDLE hFile, LPVOID buffer, DWORD bytesToRead, LPDWORD bytesRead)
1576 {
1577 OVERLAPPED ov;
1578 BOOL r = FALSE;
1579
1580 TRACE("%d %p %ld %p\n", hFile, buffer, bytesToRead, bytesRead );
1581
1582 ZeroMemory(&ov, sizeof (OVERLAPPED));
1583 if(STATUS_SUCCESS==NtCreateEvent(&ov.hEvent, SYNCHRONIZE, NULL, 0, 0))
1584 {
1585 if(FILE_ReadFileEx(hFile, buffer, bytesToRead, &ov, NULL, ov.hEvent))
1586 {
1587 r = GetOverlappedResult(hFile, &ov, bytesRead, TRUE);
1588 }
1589 }
1590 CloseHandle(ov.hEvent);
1591 return r;
1592 }
1593
1594 /***********************************************************************
1595 * ReadFile (KERNEL32.@)
1596 */
1597 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1598 LPDWORD bytesRead, LPOVERLAPPED overlapped )
1599 {
1600 int unix_handle, result, flags;
1601 enum fd_type type;
1602
1603 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToRead,
1604 bytesRead, overlapped );
1605
1606 if (bytesRead) *bytesRead = 0; /* Do this before anything else */
1607 if (!bytesToRead) return TRUE;
1608
1609 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_READ, &type, &flags );
1610
1611 if (flags & FD_FLAG_OVERLAPPED)
1612 {
1613 if (unix_handle == -1) return FALSE;
1614 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
1615 {
1616 TRACE("Overlapped not specified or invalid event flag\n");
1617 close(unix_handle);
1618 SetLastError(ERROR_INVALID_PARAMETER);
1619 return FALSE;
1620 }
1621
1622 close(unix_handle);
1623 overlapped->InternalHigh = 0;
1624
1625 if(!FILE_ReadFileEx(hFile, buffer, bytesToRead, overlapped, NULL, overlapped->hEvent))
1626 return FALSE;
1627
1628 if ( !GetOverlappedResult (hFile, overlapped, bytesRead, FALSE) )
1629 {
1630 if ( GetLastError() == ERROR_IO_INCOMPLETE )
1631 SetLastError ( ERROR_IO_PENDING );
1632 return FALSE;
1633 }
1634
1635 return TRUE;
1636 }
1637 if (flags & FD_FLAG_TIMEOUT)
1638 {
1639 close(unix_handle);
1640 return FILE_TimeoutRead(hFile, buffer, bytesToRead, bytesRead);
1641 }
1642 switch(type)
1643 {
1644 case FD_TYPE_SMB:
1645 return SMB_ReadFile(hFile, buffer, bytesToRead, bytesRead, NULL);
1646 case FD_TYPE_CONSOLE:
1647 return ReadConsoleA(hFile, buffer, bytesToRead, bytesRead, NULL);
1648
1649 default:
1650 /* normal unix files */
1651 if (unix_handle == -1)
1652 return FALSE;
1653 if (overlapped)
1654 {
1655 close(unix_handle);
1656 SetLastError(ERROR_INVALID_PARAMETER);
1657 return FALSE;
1658 }
1659 break;
1660 }
1661
1662 /* code for synchronous reads */
1663 while ((result = read( unix_handle, buffer, bytesToRead )) == -1)
1664 {
1665 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1666 if ((errno == EFAULT) && !IsBadWritePtr( buffer, bytesToRead )) continue;
1667 FILE_SetDosError();
1668 break;
1669 }
1670 close( unix_handle );
1671 if (result == -1) return FALSE;
1672 if (bytesRead) *bytesRead = result;
1673 return TRUE;
1674 }
1675
1676
1677 /***********************************************************************
1678 * FILE_AsyncWriteService (INTERNAL)
1679 *
1680 * This function is called while the client is waiting on the
1681 * server, so we can't make any server calls here.
1682 */
1683 static void FILE_AsyncWriteService(struct async_private *ovp)
1684 {
1685 async_fileio *fileio = (async_fileio *) ovp;
1686 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1687 int result, r;
1688 int already = lpOverlapped->InternalHigh;
1689
1690 TRACE("(%p %p)\n",lpOverlapped,fileio->buffer);
1691
1692 /* write some data (non-blocking) */
1693
1694 if ( fileio->fd_type == FD_TYPE_SOCKET )
1695 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1696 else
1697 {
1698 result = pwrite(ovp->fd, &fileio->buffer[already], fileio->count - already,
1699 OVERLAPPED_OFFSET (lpOverlapped) + already);
1700 if ((result < 0) && (errno == ESPIPE))
1701 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1702 }
1703
1704 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1705 {
1706 r = STATUS_PENDING;
1707 goto async_end;
1708 }
1709
1710 /* check to see if the transfer is complete */
1711 if(result<0)
1712 {
1713 r = FILE_GetNtStatus ();
1714 goto async_end;
1715 }
1716
1717 lpOverlapped->InternalHigh += result;
1718
1719 TRACE("wrote %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1720
1721 if(lpOverlapped->InternalHigh < fileio->count)
1722 r = STATUS_PENDING;
1723 else
1724 r = STATUS_SUCCESS;
1725
1726 async_end:
1727 lpOverlapped->Internal = r;
1728 }
1729
1730 /***********************************************************************
1731 * FILE_WriteFileEx
1732 */
1733 static BOOL FILE_WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1734 LPOVERLAPPED overlapped,
1735 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1736 HANDLE hEvent)
1737 {
1738 async_fileio *ovp;
1739 int fd;
1740 int flags;
1741 enum fd_type type;
1742
1743 TRACE("file %d to buf %p num %ld %p func %p handle %d\n",
1744 hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, hEvent);
1745
1746 if (overlapped == NULL)
1747 {
1748 SetLastError(ERROR_INVALID_PARAMETER);
1749 return FALSE;
1750 }
1751
1752 fd = FILE_GetUnixHandleType ( hFile, GENERIC_WRITE, &type, &flags );
1753 if ( fd < 0 )
1754 {
1755 TRACE( "Couldn't get FD\n" );
1756 return FALSE;
1757 }
1758
1759 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1760 if(!ovp)
1761 {
1762 TRACE("HeapAlloc Failed\n");
1763 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1764 goto error;
1765 }
1766
1767 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1768 ovp->async.handle = hFile;
1769 ovp->async.fd = fd;
1770 ovp->async.type = ASYNC_TYPE_WRITE;
1771 ovp->async.func = FILE_AsyncWriteService;
1772 ovp->lpOverlapped = overlapped;
1773 ovp->async.event = hEvent;
1774 ovp->buffer = (LPVOID) buffer;
1775 ovp->count = bytesToWrite;
1776 ovp->completion_func = lpCompletionRoutine;
1777 ovp->fd_type = type;
1778
1779 return !register_new_async (&ovp->async);
1780
1781 error:
1782 close (fd);
1783 return FALSE;
1784 }
1785
1786 /***********************************************************************
1787 * WriteFileEx (KERNEL32.@)
1788 */
1789 BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1790 LPOVERLAPPED overlapped,
1791 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1792 {
1793 overlapped->InternalHigh = 0;
1794
1795 return FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, INVALID_HANDLE_VALUE);
1796 }
1797
1798 /***********************************************************************
1799 * WriteFile (KERNEL32.@)
1800 */
1801 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1802 LPDWORD bytesWritten, LPOVERLAPPED overlapped )
1803 {
1804 int unix_handle, result, flags;
1805 enum fd_type type;
1806
1807 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToWrite,
1808 bytesWritten, overlapped );
1809
1810 if (bytesWritten) *bytesWritten = 0; /* Do this before anything else */
1811 if (!bytesToWrite) return TRUE;
1812
1813 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_WRITE, &type, &flags );
1814
1815 if (flags & FD_FLAG_OVERLAPPED)
1816 {
1817 if (unix_handle == -1) return FALSE;
1818 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
1819 {
1820 TRACE("Overlapped not specified or invalid event flag\n");
1821 close(unix_handle);
1822 SetLastError(ERROR_INVALID_PARAMETER);
1823 return FALSE;
1824 }
1825
1826 close(unix_handle);
1827 overlapped->InternalHigh = 0;
1828
1829 if(!FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, NULL, overlapped->hEvent))
1830 return FALSE;
1831
1832 if ( !GetOverlappedResult (hFile, overlapped, bytesWritten, FALSE) )
1833 {
1834 if ( GetLastError() == ERROR_IO_INCOMPLETE )
1835 SetLastError ( ERROR_IO_PENDING );
1836 return FALSE;
1837 }
1838
1839 return TRUE;
1840 }
1841
1842 switch(type)
1843 {
1844 case FD_TYPE_CONSOLE:
1845 TRACE("%d %s %ld %p %p\n", hFile, debugstr_an(buffer, bytesToWrite), bytesToWrite,
1846 bytesWritten, overlapped );
1847 return WriteConsoleA(hFile, buffer, bytesToWrite, bytesWritten, NULL);
1848 default:
1849 if (unix_handle == -1)
1850 return FALSE;
1851 }
1852
1853 /* synchronous file write */
1854 while ((result = write( unix_handle, buffer, bytesToWrite )) == -1)
1855 {
1856 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1857 if ((errno == EFAULT) && !IsBadReadPtr( buffer, bytesToWrite )) continue;
1858 if (errno == ENOSPC)
1859 SetLastError( ERROR_DISK_FULL );
1860 else
1861 FILE_SetDosError();
1862 break;
1863 }
1864 close( unix_handle );
1865 if (result == -1) return FALSE;
1866 if (bytesWritten) *bytesWritten = result;
1867 return TRUE;
1868 }
1869
1870
1871 /***********************************************************************
1872 * _hread (KERNEL.349)
1873 */
1874 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
1875 {
1876 LONG maxlen;
1877
1878 TRACE("%d %08lx %ld\n",
1879 hFile, (DWORD)buffer, count );
1880
1881 /* Some programs pass a count larger than the allocated buffer */
1882 maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
1883 if (count > maxlen) count = maxlen;
1884 return _lread(DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
1885 }
1886
1887
1888 /***********************************************************************
1889 * _lread (KERNEL.82)
1890 */
1891 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
1892 {
1893 return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
1894 }
1895
1896
1897 /***********************************************************************
1898 * _lread (KERNEL32.@)
1899 */
1900 UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
1901 {
1902 DWORD result;
1903 if (!ReadFile( handle, buffer, count, &result, NULL )) return -1;
1904 return result;
1905 }
1906
1907
1908 /***********************************************************************
1909 * _lread16 (KERNEL.82)
1910 */
1911 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
1912 {
1913 return (UINT16)_lread(DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
1914 }
1915
1916
1917 /***********************************************************************
1918 * _lcreat (KERNEL.83)
1919 */
1920 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
1921 {
1922 return Win32HandleToDosFileHandle( _lcreat( path, attr ) );
1923 }
1924
1925
1926 /***********************************************************************
1927 * _lcreat (KERNEL32.@)
1928 */
1929 HFILE WINAPI _lcreat( LPCSTR path, INT attr )
1930 {
1931 /* Mask off all flags not explicitly allowed by the doc */
1932 attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
1933 TRACE("%s %02x\n", path, attr );
1934 return CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
1935 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1936 CREATE_ALWAYS, attr, 0 );
1937 }
1938
1939
1940 /***********************************************************************
1941 * SetFilePointer (KERNEL32.@)
1942 */
1943 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
1944 DWORD method )
1945 {
1946 DWORD ret = 0xffffffff;
1947
1948 TRACE("handle %d offset %ld high %ld origin %ld\n",
1949 hFile, distance, highword?*highword:0, method );
1950
1951 SERVER_START_REQ( set_file_pointer )
1952 {
1953 req->handle = hFile;
1954 req->low = distance;
1955 req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
1956 /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
1957 req->whence = method;
1958 SetLastError( 0 );
1959 if (!wine_server_call_err( req ))
1960 {
1961 ret = reply->new_low;
1962 if (highword) *highword = reply->new_high;
1963 }
1964 }
1965 SERVER_END_REQ;
1966 return ret;
1967 }
1968
1969
1970 /***********************************************************************
1971 * _llseek (KERNEL.84)
1972 *
1973 * FIXME:
1974 * Seeking before the start of the file should be allowed for _llseek16,
1975 * but cause subsequent I/O operations to fail (cf. interrupt list)
1976 *
1977 */
1978 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
1979 {
1980 return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
1981 }
1982
1983
1984 /***********************************************************************
1985 * _llseek (KERNEL32.@)
1986 */
1987 LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
1988 {
1989 return SetFilePointer( hFile, lOffset, NULL, nOrigin );
1990 }
1991
1992
1993 /***********************************************************************
1994 * _lopen (KERNEL.85)
1995 */
1996 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
1997 {
1998 return Win32HandleToDosFileHandle( _lopen( path, mode ) );
1999 }
2000
2001
2002 /***********************************************************************
2003 * _lopen (KERNEL32.@)
2004 */
2005 HFILE WINAPI _lopen( LPCSTR path, INT mode )
2006 {
2007 DWORD access, sharing;
2008
2009 TRACE("('%s',%04x)\n", path, mode );
2010 FILE_ConvertOFMode( mode, &access, &sharing );
2011 return CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, 0 );
2012 }
2013
2014
2015 /***********************************************************************
2016 * _lwrite (KERNEL.86)
2017 */
2018 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
2019 {
2020 return (UINT16)_hwrite( DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
2021 }
2022
2023 /***********************************************************************
2024 * _lwrite (KERNEL32.@)
2025 */
2026 UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
2027 {
2028 return (UINT)_hwrite( hFile, buffer, (LONG)count );
2029 }
2030
2031
2032 /***********************************************************************
2033 * _hread16 (KERNEL.349)
2034 */
2035 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
2036 {
2037 return _lread( DosFileHandleToWin32Handle(hFile), buffer, count );
2038 }
2039
2040
2041 /***********************************************************************
2042 * _hread (KERNEL32.@)
2043 */
2044 LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
2045 {
2046 return _lread( hFile, buffer, count );
2047 }
2048
2049
2050 /***********************************************************************
2051 * _hwrite (KERNEL.350)
2052 */
2053 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
2054 {
2055 return _hwrite( DosFileHandleToWin32Handle(hFile), buffer, count );
2056 }
2057
2058
2059 /***********************************************************************
2060 * _hwrite (KERNEL32.@)
2061 *
2062 * experimentation yields that _lwrite:
2063 * o truncates the file at the current position with
2064 * a 0 len write
2065 * o returns 0 on a 0 length write
2066 * o works with console handles
2067 *
2068 */
2069 LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
2070 {
2071 DWORD result;
2072
2073 TRACE("%d %p %ld\n", handle, buffer, count );
2074
2075 if (!count)
2076 {
2077 /* Expand or truncate at current position */
2078 if (!SetEndOfFile( handle )) return HFILE_ERROR;
2079 return 0;
2080 }
2081 if (!WriteFile( handle, buffer, count, &result, NULL ))
2082 return HFILE_ERROR;
2083 return result;
2084 }
2085
2086
2087 /***********************************************************************
2088 * SetHandleCount (KERNEL.199)
2089 */
2090 UINT16 WINAPI SetHandleCount16( UINT16 count )
2091 {
2092 return SetHandleCount( count );
2093 }
2094
2095
2096 /*************************************************************************
2097 * SetHandleCount (KERNEL32.@)
2098 */
2099 UINT WINAPI SetHandleCount( UINT count )
2100 {
2101 return min( 256, count );
2102 }
2103
2104
2105 /***********************************************************************
2106 * FlushFileBuffers (KERNEL32.@)
2107 */
2108 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
2109 {
2110 BOOL ret;
2111 SERVER_START_REQ( flush_file )
2112 {
2113 req->handle = hFile;
2114 ret = !wine_server_call_err( req );
2115 }
2116 SERVER_END_REQ;
2117 return ret;
2118 }
2119
2120
2121 /**************************************************************************
2122 * SetEndOfFile (KERNEL32.@)
2123 */
2124 BOOL WINAPI SetEndOfFile( HANDLE hFile )
2125 {
2126 BOOL ret;
2127 SERVER_START_REQ( truncate_file )
2128 {
2129 req->handle = hFile;
2130 ret = !wine_server_call_err( req );
2131 }
2132 SERVER_END_REQ;
2133 return ret;
2134 }
2135
2136
2137 /***********************************************************************
2138 * DeleteFile (KERNEL.146)
2139 */
2140 BOOL16 WINAPI DeleteFile16( LPCSTR path )
2141 {
2142 return DeleteFileA( path );
2143 }
2144
2145
2146 /***********************************************************************
2147 * DeleteFileA (KERNEL32.@)
2148 */
2149 BOOL WINAPI DeleteFileA( LPCSTR path )
2150 {
2151 DOS_FULL_NAME full_name;
2152 HANDLE hFile;
2153
2154 if (!path)
2155 {
2156 SetLastError(ERROR_INVALID_PARAMETER);
2157 return FALSE;
2158 }
2159 TRACE("'%s'\n", path );
2160
2161 if (!*path)
2162 {
2163 ERR("Empty path passed\n");
2164 return FALSE;
2165 }
2166 if (DOSFS_GetDevice( path ))
2167 {
2168 WARN("cannot remove DOS device '%s'!\n", path);
2169 SetLastError( ERROR_FILE_NOT_FOUND );
2170 return FALSE;
2171 }
2172
2173 if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
2174
2175 /* check if we are allowed to delete the source */
2176 hFile = FILE_CreateFile( full_name.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2177 NULL, OPEN_EXISTING, 0, 0, TRUE,
2178 GetDriveTypeA( full_name.short_name ) );
2179 if (!hFile) return FALSE;
2180
2181 if (unlink( full_name.long_name ) == -1)
2182 {
2183 FILE_SetDosError();
2184 CloseHandle(hFile);
2185 return FALSE;
2186 }
2187 CloseHandle(hFile);
2188 return TRUE;
2189 }
2190
2191
2192 /***********************************************************************
2193 * DeleteFileW (KERNEL32.@)
2194 */
2195 BOOL WINAPI DeleteFileW( LPCWSTR path )
2196 {
2197 LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
2198 BOOL ret = DeleteFileA( xpath );
2199 HeapFree( GetProcessHeap(), 0, xpath );
2200 return ret;
2201 }
2202
2203
2204 /***********************************************************************
2205 * GetFileType (KERNEL32.@)
2206 */
2207 DWORD WINAPI GetFileType( HANDLE hFile )
2208 {
2209 DWORD ret = FILE_TYPE_UNKNOWN;
2210 SERVER_START_REQ( get_file_info )
2211 {
2212 req->handle = hFile;
2213 if (!wine_server_call_err( req )) ret = reply->type;
2214 }
2215 SERVER_END_REQ;
2216 return ret;
2217 }
2218
2219
2220 /* check if a file name is for an executable file (.exe or .com) */
2221 inline static BOOL is_executable( const char *name )
2222 {
2223 int len = strlen(name);
2224
2225 if (len < 4) return FALSE;
2226 return (!strcasecmp( name + len - 4, ".exe" ) ||
2227 !strcasecmp( name + len - 4, ".com" ));
2228 }
2229
2230
2231 /***********************************************************************
2232 * FILE_AddBootRenameEntry
2233 *
2234 * Adds an entry to the registry that is loaded when windows boots and
2235 * checks if there are some files to be removed or renamed/moved.
2236 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
2237 * non-NULL then the file is moved, otherwise it is deleted. The
2238 * entry of the registrykey is always appended with two zero
2239 * terminated strings. If <fn2> is NULL then the second entry is
2240 * simply a single 0-byte. Otherwise the second filename goes
2241 * there. The entries are prepended with \??\ before the path and the
2242 * second filename gets also a '!' as the first character if
2243 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
2244 * 0-byte follows to indicate the end of the strings.
2245 * i.e.:
2246 * \??\D:\test\file1[0]
2247 * !\??\D:\test\file1_renamed[0]
2248 * \??\D:\Test|delete[0]
2249 * [0] <- file is to be deleted, second string empty
2250 * \??\D:\test\file2[0]
2251 * !\??\D:\test\file2_renamed[0]
2252 * [0] <- indicates end of strings
2253 *
2254 * or:
2255 * \??\D:\test\file1[0]
2256 * !\??\D:\test\file1_renamed[0]
2257 * \??\D:\Test|delete[0]
2258 * [0] <- file is to be deleted, second string empty
2259 * [0] <- indicates end of strings
2260 *
2261 */
2262 static BOOL FILE_AddBootRenameEntry( const char *fn1, const char *fn2, DWORD flags )
2263 {
2264 static const char PreString[] = "\\??\\";
2265 static const char ValueName[] = "PendingFileRenameOperations";
2266
2267 BOOL rc = FALSE;
2268 HKEY Reboot = 0;
2269 DWORD Type, len1, len2, l;
2270 DWORD DataSize = 0;
2271 BYTE *Buffer = NULL;
2272
2273 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Session Manager",
2274 &Reboot) != ERROR_SUCCESS)
2275 {
2276 WARN("Error creating key for reboot managment [%s]\n",
2277 "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
2278 return FALSE;
2279 }
2280
2281 l = strlen(PreString);
2282 len1 = strlen(fn1) + l + 1;
2283 if (fn2)
2284 {
2285 len2 = strlen(fn2) + l + 1;
2286 if (flags & MOVEFILE_REPLACE_EXISTING) len2++; /* Plus 1 because of the leading '!' */
2287 }
2288 else len2 = 1; /* minimum is the 0 byte for the empty second string */
2289
2290 /* First we check if the key exists and if so how many bytes it already contains. */
2291 if (RegQueryValueExA(Reboot, ValueName, NULL, &Type, NULL, &DataSize) == ERROR_SUCCESS)
2292 {
2293 if (Type != REG_MULTI_SZ) goto Quit;
2294 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + 1 ))) goto Quit;
2295 if (RegQueryValueExA(Reboot, ValueName, NULL, &Type, Buffer, &DataSize) != ERROR_SUCCESS)
2296 goto Quit;
2297 if (DataSize) DataSize--; /* remove terminating null (will be added back later) */
2298 }
2299 else
2300 {
2301 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, len1 + len2 + 1 ))) goto Quit;
2302 DataSize = 0;
2303 }
2304 sprintf( Buffer + DataSize, "%s%s", PreString, fn1 );
2305 DataSize += len1;
2306 if (fn2)
2307 {
2308 sprintf( Buffer + DataSize, "%s%s%s",
2309 (flags & MOVEFILE_REPLACE_EXISTING) ? "!" : "", PreString, fn2 );
2310 DataSize += len2;
2311 }
2312 else Buffer[DataSize++] = 0;
2313
2314 Buffer[DataSize++] = 0; /* add final null */
2315 rc = !RegSetValueExA( Reboot, ValueName, 0, REG_MULTI_SZ, Buffer, DataSize );
2316
2317 Quit:
2318 if (Reboot) RegCloseKey(Reboot);
2319 if (Buffer) HeapFree( GetProcessHeap(), 0, Buffer );
2320 return(rc);
2321 }
2322
2323
2324 /**************************************************************************
2325 * MoveFileExA (KERNEL32.@)
2326 */
2327 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
2328 {
2329 DOS_FULL_NAME full_name1, full_name2;
2330 HANDLE hFile;
2331
2332 TRACE("(%s,%s,%04lx)\n", fn1, fn2, flag);
2333
2334 /* FIXME: <Gerhard W. Gruber>sparhawk@gmx.at
2335 In case of W9x and lesser this function should return 120 (ERROR_CALL_NOT_IMPLEMENTED)
2336 to be really compatible. Most programs wont have any problems though. In case
2337 you encounter one, this is what you should return here. I don't know what's up
2338 with NT 3.5. Is this function available there or not?
2339 Does anybody really care about 3.5? :)
2340 */
2341
2342 /* Filename1 has to be always set to a valid path. Filename2 may be NULL
2343 if the source file has to be deleted.
2344 */
2345 if (!fn1) {
2346 SetLastError(ERROR_INVALID_PARAMETER);
2347 return FALSE;
2348 }
2349
2350 /* This function has to be run through in order to process the name properly.
2351 If the BOOTDELAY flag is set, the file doesn't need to exist though. At least
2352 that is the behaviour on NT 4.0. The operation accepts the filenames as
2353 they are given but it can't reply with a reasonable returncode. Success
2354 means in that case success for entering the values into the registry.
2355 */
2356 if(!DOSFS_GetFullName( fn1, TRUE, &full_name1 ))
2357 {
2358 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2359 return FALSE;
2360 }
2361
2362 if (fn2) /* !fn2 means delete fn1 */
2363 {
2364 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
2365 {
2366 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2367 {
2368 /* target exists, check if we may overwrite */
2369 if (!(flag & MOVEFILE_REPLACE_EXISTING))
2370 {
2371 /* FIXME: Use right error code */
2372 SetLastError( ERROR_ACCESS_DENIED );
2373 return FALSE;
2374 }
2375 }
2376 }
2377 else
2378 {
2379 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 ))
2380 {
2381 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2382 return FALSE;
2383 }
2384 }
2385
2386 /* Source name and target path are valid */
2387
2388 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2389 {
2390 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2391 Perhaps we should queue these command and execute it
2392 when exiting... What about using on_exit(2)
2393 */
2394 FIXME("Please move existing file '%s' to file '%s' when Wine has finished\n",
2395 fn1, fn2);
2396 return FILE_AddBootRenameEntry( fn1, fn2, flag );
2397 }
2398
2399 /* check if we are allowed to delete the source */
2400 hFile = FILE_CreateFile( full_name1.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2401 NULL, OPEN_EXISTING, 0, 0, TRUE,
2402 GetDriveTypeA( full_name1.short_name ) );
2403 if (!hFile) return FALSE;
2404 CloseHandle(hFile);
2405
2406 /* check, if we are allowed to delete the destination,
2407 ** (but the file not being there is fine) */
2408 hFile = FILE_CreateFile( full_name2.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2409 NULL, OPEN_EXISTING, 0, 0, TRUE,
2410 GetDriveTypeA( full_name2.short_name ) );
2411 if(!hFile && GetLastError() != ERROR_FILE_NOT_FOUND) return FALSE;
2412 CloseHandle(hFile);
2413
2414 if (full_name1.drive != full_name2.drive)
2415 {
2416 /* use copy, if allowed */
2417 if (!(flag & MOVEFILE_COPY_ALLOWED))
2418 {
2419 /* FIXME: Use right error code */
2420 SetLastError( ERROR_FILE_EXISTS );
2421 return FALSE;
2422 }
2423 return CopyFileA( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) );
2424 }
2425 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
2426 {
2427 FILE_SetDosError();
2428 return FALSE;
2429 }
2430 if (is_executable( full_name1.long_name ) != is_executable( full_name2.long_name ))
2431 {
2432 struct stat fstat;
2433 if (stat( full_name2.long_name, &fstat ) != -1)
2434 {
2435 if (is_executable( full_name2.long_name ))
2436 /* set executable bit where read bit is set */
2437 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
2438 else
2439 fstat.st_mode &= ~0111;
2440 chmod( full_name2.long_name, fstat.st_mode );
2441 }
2442 }
2443 return TRUE;
2444 }
2445 else /* fn2 == NULL means delete source */
2446 {
2447 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2448 {
2449 if (flag & MOVEFILE_COPY_ALLOWED) {
2450 WARN("Illegal flag\n");
2451 SetLastError( ERROR_GEN_FAILURE );
2452 return FALSE;
2453 }
2454 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2455 Perhaps we should queue these command and execute it
2456 when exiting... What about using on_exit(2)
2457 */
2458 FIXME("Please delete file '%s' when Wine has finished\n", fn1);
2459 return FILE_AddBootRenameEntry( fn1, NULL, flag );
2460 }
2461
2462 if (unlink( full_name1.long_name ) == -1)
2463 {
2464 FILE_SetDosError();
2465 return FALSE;
2466 }
2467 return TRUE; /* successfully deleted */
2468 }
2469 }
2470
2471 /**************************************************************************
2472 * MoveFileExW (KERNEL32.@)
2473 */
2474 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
2475 {
2476 LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
2477 LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
2478 BOOL res = MoveFileExA( afn1, afn2, flag );
2479 HeapFree( GetProcessHeap(), 0, afn1 );
2480 HeapFree( GetProcessHeap(), 0, afn2 );
2481 return res;
2482 }
2483
2484
2485 /**************************************************************************
2486 * MoveFileA (KERNEL32.@)
2487 *
2488 * Move file or directory
2489 */
2490 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
2491 {
2492 DOS_FULL_NAME full_name1, full_name2;
2493 struct stat fstat;
2494
2495 TRACE("(%s,%s)\n", fn1, fn2 );
2496
2497 if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
2498 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) {
2499 /* The new name must not already exist */
2500 SetLastError(ERROR_ALREADY_EXISTS);
2501 return FALSE;
2502 }
2503 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
2504
2505 if (full_name1.drive == full_name2.drive) /* move */
2506 return MoveFileExA( fn1, fn2, MOVEFILE_COPY_ALLOWED );
2507
2508 /* copy */
2509 if (stat( full_name1.long_name, &fstat ))
2510 {
2511 WARN("Invalid source file %s\n",
2512 full_name1.long_name);
2513 FILE_SetDosError();
2514 return FALSE;
2515 }
2516 if (S_ISDIR(fstat.st_mode)) {
2517 /* No Move for directories across file systems */
2518 /* FIXME: Use right error code */
2519 SetLastError( ERROR_GEN_FAILURE );
2520 return FALSE;
2521 }
2522 return CopyFileA(fn1, fn2, TRUE); /*fail, if exist */
2523 }
2524
2525
2526 /**************************************************************************
2527 * MoveFileW (KERNEL32.@)
2528 */
2529 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
2530 {
2531 LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
2532 LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
2533 BOOL res = MoveFileA( afn1, afn2 );
2534 HeapFree( GetProcessHeap(), 0, afn1 );
2535 HeapFree( GetProcessHeap(), 0, afn2 );
2536 return res;
2537 }
2538
2539
2540 /**************************************************************************
2541 * CopyFileA (KERNEL32.@)
2542 */
2543 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists )
2544 {
2545 HFILE h1, h2;
2546 BY_HANDLE_FILE_INFORMATION info;
2547 UINT count;
2548 BOOL ret = FALSE;
2549 int mode;
2550 char buffer[2048];
2551
2552 if ((h1 = _lopen( source, OF_READ )) == HFILE_ERROR) return FALSE;
2553 if (!GetFileInformationByHandle( h1, &info ))
2554 {
2555 CloseHandle( h1 );
2556 return FALSE;
2557 }
2558 mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
2559 if ((h2 = CreateFileA( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2560 fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
2561 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
2562 {
2563 CloseHandle( h1 );
2564 return FALSE;
2565 }
2566 while ((count = _lread( h1, buffer, sizeof(buffer) )) > 0)
2567 {
2568 char *p = buffer;
2569 while (count > 0)
2570 {
2571 INT res = _lwrite( h2, p, count );
2572 if (res <= 0) goto done;
2573 p += res;
2574 count -= res;
2575 }
2576 }
2577 ret = TRUE;
2578 done:
2579 CloseHandle( h1 );
2580 CloseHandle( h2 );
2581 return ret;
2582 }
2583
2584
2585 /**************************************************************************
2586 * CopyFileW (KERNEL32.@)
2587 */
2588 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists)
2589 {
2590 LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
2591 LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
2592 BOOL ret = CopyFileA( sourceA, destA, fail_if_exists );
2593 HeapFree( GetProcessHeap(), 0, sourceA );
2594 HeapFree( GetProcessHeap(), 0, destA );
2595 return ret;
2596 }
2597
2598
2599 /**************************************************************************
2600 * CopyFileExA (KERNEL32.@)
2601 *
2602 * This implementation ignores most of the extra parameters passed-in into
2603 * the "ex" version of the method and calls the CopyFile method.
2604 * It will have to be fixed eventually.
2605 */
2606 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename,
2607 LPCSTR destFilename,
2608 LPPROGRESS_ROUTINE progressRoutine,
2609 LPVOID appData,
2610 LPBOOL cancelFlagPointer,
2611 DWORD copyFlags)
2612 {
2613 BOOL failIfExists = FALSE;
2614
2615 /*
2616 * Interpret the only flag that CopyFile can interpret.
2617 */
2618 if ( (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0)
2619 {
2620 failIfExists = TRUE;
2621 }
2622
2623 return CopyFileA(sourceFilename, destFilename, failIfExists);
2624 }
2625
2626 /**************************************************************************
2627 * CopyFileExW (KERNEL32.@)
2628 */
2629 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename,
2630 LPCWSTR destFilename,
2631 LPPROGRESS_ROUTINE progressRoutine,
2632 LPVOID appData,
2633 LPBOOL cancelFlagPointer,
2634 DWORD copyFlags)
2635 {
2636 LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, sourceFilename );
2637 LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, destFilename );
2638
2639 BOOL ret = CopyFileExA(sourceA,
2640 destA,
2641 progressRoutine,
2642 appData,
2643 cancelFlagPointer,
2644 copyFlags);
2645
2646 HeapFree( GetProcessHeap(), 0, sourceA );
2647 HeapFree( GetProcessHeap(), 0, destA );
2648
2649 return ret;
2650 }
2651
2652
2653 /***********************************************************************
2654 * SetFileTime (KERNEL32.@)
2655 */
2656 BOOL WINAPI SetFileTime( HANDLE hFile,
2657 const FILETIME *lpCreationTime,
2658 const FILETIME *lpLastAccessTime,
2659 const FILETIME *lpLastWriteTime )
2660 {
2661 BOOL ret;
2662 SERVER_START_REQ( set_file_time )
2663 {
2664 req->handle = hFile;
2665 if (lpLastAccessTime)
2666 RtlTimeToSecondsSince1970( lpLastAccessTime, (DWORD *)&req->access_time );
2667 else
2668 req->access_time = 0; /* FIXME */
2669 if (lpLastWriteTime)
2670 RtlTimeToSecondsSince1970( lpLastWriteTime, (DWORD *)&req->write_time );
2671 else
2672 req->write_time = 0; /* FIXME */
2673 ret = !wine_server_call_err( req );
2674 }
2675 SERVER_END_REQ;
2676 return ret;
2677 }
2678
2679
2680 /**************************************************************************
2681 * LockFile (KERNEL32.@)
2682 */
2683 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
2684 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
2685 {
2686 BOOL ret;
2687 SERVER_START_REQ( lock_file )
2688 {
2689 req->handle = hFile;
2690 req->offset_low = dwFileOffsetLow;
2691 req->offset_high = dwFileOffsetHigh;
2692 req->count_low = nNumberOfBytesToLockLow;
2693 req->count_high = nNumberOfBytesToLockHigh;
2694 ret = !wine_server_call_err( req );
2695 }
2696 SERVER_END_REQ;
2697 return ret;
2698 }
2699
2700 /**************************************************************************
2701 * LockFileEx [KERNEL32.@]
2702 *
2703 * Locks a byte range within an open file for shared or exclusive access.
2704 *
2705 * RETURNS
2706 * success: TRUE
2707 * failure: FALSE
2708 *
2709 * NOTES
2710 * Per Microsoft docs, the third parameter (reserved) must be set to 0.
2711 */
2712 BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
2713 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
2714 LPOVERLAPPED pOverlapped )
2715 {
2716 FIXME("hFile=%d,flags=%ld,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
2717 hFile, flags, reserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh,
2718 pOverlapped);
2719 if (reserved == 0)
2720 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2721 else
2722 {
2723 ERR("reserved == %ld: Supposed to be 0??\n", reserved);
2724 SetLastError(ERROR_INVALID_PARAMETER);
2725 }
2726
2727 return FALSE;
2728 }
2729
2730
2731 /**************************************************************************
2732 * UnlockFile (KERNEL32.@)
2733 */
2734 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
2735 DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
2736 {
2737 BOOL ret;
2738 SERVER_START_REQ( unlock_file )
2739 {
2740 req->handle = hFile;
2741 req->offset_low = dwFileOffsetLow;
2742 req->offset_high = dwFileOffsetHigh;
2743 req->count_low = nNumberOfBytesToUnlockLow;
2744 req->count_high = nNumberOfBytesToUnlockHigh;
2745 ret = !wine_server_call_err( req );
2746 }
2747 SERVER_END_REQ;
2748 return ret;
2749 }
2750
2751
2752 /**************************************************************************
2753 * UnlockFileEx (KERNEL32.@)
2754 */
2755 BOOL WINAPI UnlockFileEx(
2756 HFILE hFile,
2757 DWORD dwReserved,
2758 DWORD nNumberOfBytesToUnlockLow,
2759 DWORD nNumberOfBytesToUnlockHigh,
2760 LPOVERLAPPED lpOverlapped
2761 )
2762 {
2763 FIXME("hFile=%d,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
2764 hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh,
2765 lpOverlapped);
2766 if (dwReserved == 0)
2767 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2768 else
2769 {
2770 ERR("reserved == %ld: Supposed to be 0??\n", dwReserved);
2771 SetLastError(ERROR_INVALID_PARAMETER);
2772 }
2773
2774 return FALSE;
2775 }
2776
2777
2778 #if 0
2779
2780 struct DOS_FILE_LOCK {
2781 struct DOS_FILE_LOCK * next;
2782 DWORD base;
2783 DWORD len;
2784 DWORD processId;
2785 FILE_OBJECT * dos_file;
2786 /* char * unix_name;*/
2787 };
2788
2789 typedef struct DOS_FILE_LOCK DOS_FILE_LOCK;
2790
2791 static DOS_FILE_LOCK *locks = NULL;
2792 static void DOS_RemoveFileLocks(FILE_OBJECT *file);
2793
2794
2795 /* Locks need to be mirrored because unix file locking is based
2796 * on the pid. Inside of wine there can be multiple WINE processes
2797 * that share the same unix pid.
2798 * Read's and writes should check these locks also - not sure
2799 * how critical that is at this point (FIXME).
2800 */
2801
2802 static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
2803 {
2804 DOS_FILE_LOCK *curr;
2805 DWORD processId;
2806
2807 processId = GetCurrentProcessId();
2808
2809 /* check if lock overlaps a current lock for the same file */
2810 #if 0
2811 for (curr = locks; curr; curr = curr->next) {
2812 if (strcmp(curr->unix_name, file->unix_name) == 0) {
2813 if ((f->l_start == curr->base) && (f->l_len == curr->len))
2814 return TRUE;/* region is identic */
2815 if ((f->l_start < (curr->base + curr->len)) &&
2816 ((f->l_start + f->l_len) > curr->base)) {
2817 /* region overlaps */
2818 return FALSE;
2819 }
2820 }
2821 }
2822 #endif
2823
2824 curr = HeapAlloc( GetProcessHeap(), 0, sizeof(DOS_FILE_LOCK) );
2825 curr->processId = GetCurrentProcessId();
2826 curr->base = f->l_start;
2827 curr->len = f->l_len;
2828 /* curr->unix_name = HEAP_strdupA( GetProcessHeap(), 0, file->unix_name);*/
2829 curr->next = locks;
2830 curr->dos_file = file;
2831 locks = curr;
2832 return TRUE;
2833 }
2834
2835 static void DOS_RemoveFileLocks(FILE_OBJECT *file)
2836 {
2837 DWORD processId;
2838 DOS_FILE_LOCK **curr;
2839 DOS_FILE_LOCK *rem;
2840
2841 processId = GetCurrentProcessId();
2842 curr = &locks;
2843 while (*curr) {
2844 if ((*curr)->dos_file == file) {
2845 rem = *curr;
2846 *curr = (*curr)->next;
2847 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2848 HeapFree( GetProcessHeap(), 0, rem );
2849 }
2850 else
2851 curr = &(*curr)->next;
2852 }
2853 }
2854
2855 static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
2856 {
2857 DWORD processId;
2858 DOS_FILE_LOCK **curr;
2859 DOS_FILE_LOCK *rem;
2860
2861 processId = GetCurrentProcessId();
2862 for (curr = &locks; *curr; curr = &(*curr)->next) {
2863 if ((*curr)->processId == processId &&
2864 (*curr)->dos_file == file &&
2865 (*curr)->base == f->l_start &&
2866 (*curr)->len == f->l_len) {
2867 /* this is the same lock */
2868 rem = *curr;
2869 *curr = (*curr)->next;
2870 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2871 HeapFree( GetProcessHeap(), 0, rem );
2872 return TRUE;
2873 }
2874 }
2875 /* no matching lock found */
2876 return FALSE;
2877 }
2878
2879
2880 /**************************************************************************
2881 * LockFile (KERNEL32.@)
2882 */
2883 BOOL WINAPI LockFile(
2884 HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2885 DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
2886 {
2887 struct flock f;
2888 FILE_OBJECT *file;
2889
2890 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2891 hFile, dwFileOffsetLow, dwFileOffsetHigh,
2892 nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh);
2893
2894 if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) {
2895 FIXME("Unimplemented bytes > 32bits\n");
2896 return FALSE;
2897 }
2898
2899 f.l_start = dwFileOffsetLow;
2900 f.l_len = nNumberOfBytesToLockLow;
2901 f.l_whence = SEEK_SET;
2902 f.l_pid = 0;
2903 f.l_type = F_WRLCK;
2904
2905 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2906
2907 /* shadow locks internally */
2908 if (!DOS_AddLock(file, &f)) {
2909 SetLastError( ERROR_LOCK_VIOLATION );
2910 return FALSE;
2911 }
2912
2913 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2914 #ifdef USE_UNIX_LOCKS
2915 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2916 if (errno == EACCES || errno == EAGAIN) {
2917 SetLastError( ERROR_LOCK_VIOLATION );
2918 }
2919 else {
2920 FILE_SetDosError();
2921 }
2922 /* remove our internal copy of the lock */
2923 DOS_RemoveLock(file, &f);
2924 return FALSE;
2925 }
2926 #endif
2927 return TRUE;
2928 }
2929
2930
2931 /**************************************************************************
2932 * UnlockFile (KERNEL32.@)
2933 */
2934 BOOL WINAPI UnlockFile(
2935 HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2936 DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
2937 {
2938 FILE_OBJECT *file;
2939 struct flock f;
2940
2941 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2942 hFile, dwFileOffsetLow, dwFileOffsetHigh,
2943 nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);
2944
2945 if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) {
2946 WARN("Unimplemented bytes > 32bits\n");
2947 return FALSE;
2948 }
2949
2950 f.l_start = dwFileOffsetLow;
2951 f.l_len = nNumberOfBytesToUnlockLow;
2952 f.l_whence = SEEK_SET;
2953 f.l_pid = 0;
2954 f.l_type = F_UNLCK;
2955
2956 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2957
2958 DOS_RemoveLock(file, &f); /* ok if fails - may be another wine */
2959
2960 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2961 #ifdef USE_UNIX_LOCKS
2962 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2963 FILE_SetDosError();
2964 return FALSE;
2965 }
2966 #endif
2967 return TRUE;
2968 }
2969 #endif
2970
2971 /**************************************************************************
2972 * GetFileAttributesExA [KERNEL32.@]
2973 */
2974 BOOL WINAPI GetFileAttributesExA(
2975 LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2976 LPVOID lpFileInformation)
2977 {
2978 DOS_FULL_NAME full_name;
2979 BY_HANDLE_FILE_INFORMATION info;
2980
2981 if (lpFileName == NULL) return FALSE;
2982 if (lpFileInformation == NULL) return FALSE;
2983
2984 if (fInfoLevelId == GetFileExInfoStandard) {
2985 LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
2986 (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
2987 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
2988 if (!FILE_Stat( full_name.long_name, &info )) return FALSE;
2989
2990 lpFad->dwFileAttributes = info.dwFileAttributes;
2991 lpFad->ftCreationTime = info.ftCreationTime;
2992 lpFad->ftLastAccessTime = info.ftLastAccessTime;
2993 lpFad->ftLastWriteTime = info.ftLastWriteTime;
2994 lpFad->nFileSizeHigh = info.nFileSizeHigh;
2995 lpFad->nFileSizeLow = info.nFileSizeLow;
2996 }
2997 else {
2998 FIXME("invalid info level %d!\n", fInfoLevelId);
2999 return FALSE;
3000 }
3001
3002 return TRUE;
3003 }
3004
3005
3006 /**************************************************************************
3007 * GetFileAttributesExW [KERNEL32.@]
3008 */
3009 BOOL WINAPI GetFileAttributesExW(
3010 LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
3011 LPVOID lpFileInformation)
3012 {
3013 LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
3014 BOOL res =
3015 GetFileAttributesExA( nameA, fInfoLevelId, lpFileInformation);
3016 HeapFree( GetProcessHeap(), 0, nameA );
3017 return res;
3018 }
Maarten's multimedia branch