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