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