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