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