?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import wine_tsx11_lock/unlock directly from x11drv in opengl32 and
[wine/multimedia.git] / files / file.c
bloba3089a229b8dc634e9261ed449a91a1913500e59
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 %d\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 %08x\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 )
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 if (is_symlink) info->dwFileAttributes |= FILE_ATTRIBUTE_SYMLINK;
763
764 /* and now see if this is a hidden file, based on the name */
765 p = strrchr( unixName, '/');
766 p = p ? p + 1 : unixName;
767 if (*p == '.' && *(p+1) && (*(p+1) != '.' || *(p+2)))
768 {
769 static const WCHAR wineW[] = {'w','i','n','e',0};
770 static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
771 static int show_dot_files = -1;
772 if (show_dot_files == -1)
773 show_dot_files = PROFILE_GetWineIniBool(wineW, ShowDotFilesW, 0);
774 if (!show_dot_files)
775 info->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
776 }
777
778 return TRUE;
779 }
780
781
782 /***********************************************************************
783 * GetFileInformationByHandle (KERNEL32.@)
784 */
785 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
786 BY_HANDLE_FILE_INFORMATION *info )
787 {
788 DWORD ret;
789 if (!info) return 0;
790
791 TRACE("%08x\n", hFile);
792
793 SERVER_START_REQ( get_file_info )
794 {
795 req->handle = hFile;
796 if ((ret = !wine_server_call_err( req )))
797 {
798 /* FIXME: which file types are supported ?
799 * Serial ports (FILE_TYPE_CHAR) are not,
800 * and MSDN also says that pipes are not supported.
801 * FILE_TYPE_REMOTE seems to be supported according to
802 * MSDN q234741.txt */
803 if ((reply->type == FILE_TYPE_DISK) || (reply->type == FILE_TYPE_REMOTE))
804 {
805 RtlSecondsSince1970ToTime( reply->write_time, (LARGE_INTEGER *)&info->ftCreationTime );
806 RtlSecondsSince1970ToTime( reply->write_time, (LARGE_INTEGER *)&info->ftLastWriteTime );
807 RtlSecondsSince1970ToTime( reply->access_time, (LARGE_INTEGER *)&info->ftLastAccessTime );
808 info->dwFileAttributes = reply->attr;
809 info->dwVolumeSerialNumber = reply->serial;
810 info->nFileSizeHigh = reply->size_high;
811 info->nFileSizeLow = reply->size_low;
812 info->nNumberOfLinks = reply->links;
813 info->nFileIndexHigh = reply->index_high;
814 info->nFileIndexLow = reply->index_low;
815 }
816 else
817 {
818 SetLastError(ERROR_NOT_SUPPORTED);
819 ret = 0;
820 }
821 }
822 }
823 SERVER_END_REQ;
824 return ret;
825 }
826
827
828 /**************************************************************************
829 * GetFileAttributes (KERNEL.420)
830 */
831 DWORD WINAPI GetFileAttributes16( LPCSTR name )
832 {
833 return GetFileAttributesA( name );
834 }
835
836
837 /**************************************************************************
838 * GetFileAttributesW (KERNEL32.@)
839 */
840 DWORD WINAPI GetFileAttributesW( LPCWSTR name )
841 {
842 DOS_FULL_NAME full_name;
843 BY_HANDLE_FILE_INFORMATION info;
844
845 if (name == NULL)
846 {
847 SetLastError( ERROR_INVALID_PARAMETER );
848 return -1;
849 }
850 if (!DOSFS_GetFullName( name, TRUE, &full_name) )
851 return -1;
852 if (!FILE_Stat( full_name.long_name, &info )) return -1;
853 return info.dwFileAttributes;
854 }
855
856
857 /**************************************************************************
858 * GetFileAttributesA (KERNEL32.@)
859 */
860 DWORD WINAPI GetFileAttributesA( LPCSTR name )
861 {
862 UNICODE_STRING nameW;
863 DWORD ret = (DWORD)-1;
864
865 if (!name)
866 {
867 SetLastError( ERROR_INVALID_PARAMETER );
868 return (DWORD)-1;
869 }
870
871 if (RtlCreateUnicodeStringFromAsciiz(&nameW, name))
872 {
873 ret = GetFileAttributesW(nameW.Buffer);
874 RtlFreeUnicodeString(&nameW);
875 }
876 else
877 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
878 return ret;
879 }
880
881
882 /**************************************************************************
883 * SetFileAttributes (KERNEL.421)
884 */
885 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
886 {
887 return SetFileAttributesA( lpFileName, attributes );
888 }
889
890
891 /**************************************************************************
892 * SetFileAttributesW (KERNEL32.@)
893 */
894 BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD attributes)
895 {
896 struct stat buf;
897 DOS_FULL_NAME full_name;
898
899 if (!lpFileName)
900 {
901 SetLastError( ERROR_INVALID_PARAMETER );
902 return FALSE;
903 }
904
905 TRACE("(%s,%lx)\n", debugstr_w(lpFileName), attributes);
906
907 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
908 return FALSE;
909
910 if(stat(full_name.long_name,&buf)==-1)
911 {
912 FILE_SetDosError();
913 return FALSE;
914 }
915 if (attributes & FILE_ATTRIBUTE_READONLY)
916 {
917 if(S_ISDIR(buf.st_mode))
918 /* FIXME */
919 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
920 else
921 buf.st_mode &= ~0222; /* octal!, clear write permission bits */
922 attributes &= ~FILE_ATTRIBUTE_READONLY;
923 }
924 else
925 {
926 /* add write permission */
927 buf.st_mode |= (0600 | ((buf.st_mode & 044) >> 1)) & (~FILE_umask);
928 }
929 if (attributes & FILE_ATTRIBUTE_DIRECTORY)
930 {
931 if (!S_ISDIR(buf.st_mode))
932 FIXME("SetFileAttributes expected the file %s to be a directory\n",
933 debugstr_w(lpFileName));
934 attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
935 }
936 attributes &= ~(FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
937 if (attributes)
938 FIXME("(%s):%lx attribute(s) not implemented.\n", debugstr_w(lpFileName), attributes);
939 if (-1==chmod(full_name.long_name,buf.st_mode))
940 {
941 if (GetDriveTypeW(lpFileName) == DRIVE_CDROM)
942 {
943 SetLastError( ERROR_ACCESS_DENIED );
944 return FALSE;
945 }
946
947 /*
948 * FIXME: We don't return FALSE here because of differences between
949 * Linux and Windows privileges. Under Linux only the owner of
950 * the file is allowed to change file attributes. Under Windows,
951 * applications expect that if you can write to a file, you can also
952 * change its attributes (see GENERIC_WRITE). We could try to be
953 * clever here but that would break multi-user installations where
954 * users share read-only DLLs. This is because some installers like
955 * to change attributes of already installed DLLs.
956 */
957 FIXME("Couldn't set file attributes for existing file \"%s\".\n"
958 "Check permissions or set VFAT \"quiet\" mount flag\n", full_name.long_name);
959 }
960 return TRUE;
961 }
962
963
964 /**************************************************************************
965 * SetFileAttributesA (KERNEL32.@)
966 */
967 BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD attributes)
968 {
969 UNICODE_STRING filenameW;
970 BOOL ret = FALSE;
971
972 if (!lpFileName)
973 {
974 SetLastError( ERROR_INVALID_PARAMETER );
975 return FALSE;
976 }
977
978 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, lpFileName))
979 {
980 ret = SetFileAttributesW(filenameW.Buffer, attributes);
981 RtlFreeUnicodeString(&filenameW);
982 }
983 else
984 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
985 return ret;
986 }
987
988
989 /***********************************************************************
990 * GetFileSize (KERNEL32.@)
991 */
992 DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD filesizehigh )
993 {
994 BY_HANDLE_FILE_INFORMATION info;
995 if (!GetFileInformationByHandle( hFile, &info )) return -1;
996 if (filesizehigh) *filesizehigh = info.nFileSizeHigh;
997 return info.nFileSizeLow;
998 }
999
1000
1001 /***********************************************************************
1002 * GetFileTime (KERNEL32.@)
1003 */
1004 BOOL WINAPI GetFileTime( HANDLE hFile, FILETIME *lpCreationTime,
1005 FILETIME *lpLastAccessTime,
1006 FILETIME *lpLastWriteTime )
1007 {
1008 BY_HANDLE_FILE_INFORMATION info;
1009 if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
1010 if (lpCreationTime) *lpCreationTime = info.ftCreationTime;
1011 if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
1012 if (lpLastWriteTime) *lpLastWriteTime = info.ftLastWriteTime;
1013 return TRUE;
1014 }
1015
1016 /***********************************************************************
1017 * CompareFileTime (KERNEL32.@)
1018 */
1019 INT WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
1020 {
1021 if (!x || !y) return -1;
1022
1023 if (x->dwHighDateTime > y->dwHighDateTime)
1024 return 1;
1025 if (x->dwHighDateTime < y->dwHighDateTime)
1026 return -1;
1027 if (x->dwLowDateTime > y->dwLowDateTime)
1028 return 1;
1029 if (x->dwLowDateTime < y->dwLowDateTime)
1030 return -1;
1031 return 0;
1032 }
1033
1034 /***********************************************************************
1035 * FILE_GetTempFileName : utility for GetTempFileName
1036 */
1037 static UINT FILE_GetTempFileName( LPCWSTR path, LPCWSTR prefix, UINT unique,
1038 LPWSTR buffer )
1039 {
1040 static UINT unique_temp;
1041 DOS_FULL_NAME full_name;
1042 int i;
1043 LPWSTR p;
1044 UINT num;
1045 char buf[20];
1046
1047 if ( !path || !prefix || !buffer )
1048 {
1049 SetLastError( ERROR_INVALID_PARAMETER );
1050 return 0;
1051 }
1052
1053 if (!unique_temp) unique_temp = time(NULL) & 0xffff;
1054 num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff);
1055
1056 strcpyW( buffer, path );
1057 p = buffer + strlenW(buffer);
1058
1059 /* add a \, if there isn't one and path is more than just the drive letter ... */
1060 if ( !((strlenW(buffer) == 2) && (buffer[1] == ':'))
1061 && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\';
1062
1063 for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
1064
1065 sprintf( buf, "%04x.tmp", num );
1066 MultiByteToWideChar(CP_ACP, 0, buf, -1, p, 20);
1067
1068 /* Now try to create it */
1069
1070 if (!unique)
1071 {
1072 do
1073 {
1074 HANDLE handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
1075 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
1076 if (handle != INVALID_HANDLE_VALUE)
1077 { /* We created it */
1078 TRACE("created %s\n", debugstr_w(buffer) );
1079 CloseHandle( handle );
1080 break;
1081 }
1082 if (GetLastError() != ERROR_FILE_EXISTS)
1083 break; /* No need to go on */
1084 num++;
1085 sprintf( buf, "%04x.tmp", num );
1086 MultiByteToWideChar(CP_ACP, 0, buf, -1, p, 20);
1087 } while (num != (unique & 0xffff));
1088 }
1089
1090 /* Get the full path name */
1091
1092 if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
1093 {
1094 char *slash;
1095 /* Check if we have write access in the directory */
1096 if ((slash = strrchr( full_name.long_name, '/' ))) *slash = '\0';
1097 if (access( full_name.long_name, W_OK ) == -1)
1098 WARN("returns %s, which doesn't seem to be writeable.\n",
1099 debugstr_w(buffer) );
1100 }
1101 TRACE("returning %s\n", debugstr_w(buffer) );
1102 return unique ? unique : num;
1103 }
1104
1105
1106 /***********************************************************************
1107 * GetTempFileNameA (KERNEL32.@)
1108 */
1109 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
1110 LPSTR buffer)
1111 {
1112 UNICODE_STRING pathW, prefixW;
1113 WCHAR bufferW[MAX_PATH];
1114 UINT ret;
1115
1116 if ( !path || !prefix || !buffer )
1117 {
1118 SetLastError( ERROR_INVALID_PARAMETER );
1119 return 0;
1120 }
1121
1122 RtlCreateUnicodeStringFromAsciiz(&pathW, path);
1123 RtlCreateUnicodeStringFromAsciiz(&prefixW, prefix);
1124
1125 ret = GetTempFileNameW(pathW.Buffer, prefixW.Buffer, unique, bufferW);
1126 if (ret)
1127 WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
1128
1129 RtlFreeUnicodeString(&pathW);
1130 RtlFreeUnicodeString(&prefixW);
1131 return ret;
1132 }
1133
1134 /***********************************************************************
1135 * GetTempFileNameW (KERNEL32.@)
1136 */
1137 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
1138 LPWSTR buffer )
1139 {
1140 return FILE_GetTempFileName( path, prefix, unique, buffer );
1141 }
1142
1143
1144 /***********************************************************************
1145 * GetTempFileName (KERNEL.97)
1146 */
1147 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
1148 LPSTR buffer )
1149 {
1150 char temppath[MAX_PATH];
1151 char *prefix16 = NULL;
1152 UINT16 ret;
1153
1154 if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
1155 drive |= DRIVE_GetCurrentDrive() + 'A';
1156
1157 if ((drive & TF_FORCEDRIVE) &&
1158 !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
1159 {
1160 drive &= ~TF_FORCEDRIVE;
1161 WARN("invalid drive %d specified\n", drive );
1162 }
1163
1164 if (drive & TF_FORCEDRIVE)
1165 sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
1166 else
1167 GetTempPathA( MAX_PATH, temppath );
1168
1169 if (prefix)
1170 {
1171 prefix16 = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + 2);
1172 *prefix16 = '~';
1173 strcpy(prefix16 + 1, prefix);
1174 }
1175
1176 ret = GetTempFileNameA( temppath, prefix16, unique, buffer );
1177
1178 if (prefix16) HeapFree(GetProcessHeap(), 0, prefix16);
1179 return ret;
1180 }
1181
1182 /***********************************************************************
1183 * FILE_DoOpenFile
1184 *
1185 * Implementation of OpenFile16() and OpenFile32().
1186 */
1187 static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode,
1188 BOOL win32 )
1189 {
1190 HFILE hFileRet;
1191 HANDLE handle;
1192 FILETIME filetime;
1193 WORD filedatetime[2];
1194 DOS_FULL_NAME full_name;
1195 DWORD access, sharing;
1196 WCHAR *p;
1197 WCHAR buffer[MAX_PATH];
1198 LPWSTR nameW;
1199
1200 if (!ofs) return HFILE_ERROR;
1201
1202 TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",name,
1203 ((mode & 0x3 )==OF_READ)?"OF_READ":
1204 ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
1205 ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
1206 ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
1207 ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
1208 ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
1209 ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
1210 ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
1211 ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
1212 ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
1213 ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
1214 ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
1215 ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
1216 ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
1217 ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
1218 ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
1219 ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
1220 );
1221
1222
1223 ofs->cBytes = sizeof(OFSTRUCT);
1224 ofs->nErrCode = 0;
1225 if (mode & OF_REOPEN) name = ofs->szPathName;
1226
1227 if (!name) {
1228 ERR("called with `name' set to NULL ! Please debug.\n");
1229 return HFILE_ERROR;
1230 }
1231
1232 TRACE("%s %04x\n", name, mode );
1233
1234 /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
1235 Are there any cases where getting the path here is wrong?
1236 Uwe Bonnes 1997 Apr 2 */
1237 if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
1238 ofs->szPathName, NULL )) goto error;
1239 FILE_ConvertOFMode( mode, &access, &sharing );
1240
1241 /* OF_PARSE simply fills the structure */
1242
1243 if (mode & OF_PARSE)
1244 {
1245 ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
1246 != DRIVE_REMOVABLE);
1247 TRACE("(%s): OF_PARSE, res = '%s'\n",
1248 name, ofs->szPathName );
1249 return 0;
1250 }
1251
1252 /* OF_CREATE is completely different from all other options, so
1253 handle it first */
1254
1255 if (mode & OF_CREATE)
1256 {
1257 if ((handle = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
1258 sharing, NULL, CREATE_ALWAYS,
1259 FILE_ATTRIBUTE_NORMAL, 0 ))== INVALID_HANDLE_VALUE)
1260 goto error;
1261 goto success;
1262 }
1263
1264 MultiByteToWideChar(CP_ACP, 0, name, -1, buffer, MAX_PATH);
1265 nameW = buffer;
1266
1267 /* If OF_SEARCH is set, ignore the given path */
1268
1269 if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
1270 {
1271 /* First try the file name as is */
1272 if (DOSFS_GetFullName( nameW, TRUE, &full_name )) goto found;
1273 /* Now remove the path */
1274 if (nameW[0] && (nameW[1] == ':')) nameW += 2;
1275 if ((p = strrchrW( nameW, '\\' ))) nameW = p + 1;
1276 if ((p = strrchrW( nameW, '/' ))) nameW = p + 1;
1277 if (!nameW[0]) goto not_found;
1278 }
1279
1280 /* Now look for the file */
1281
1282 if (!DIR_SearchPath( NULL, nameW, NULL, &full_name, win32 )) goto not_found;
1283
1284 found:
1285 TRACE("found %s = %s\n",
1286 full_name.long_name, debugstr_w(full_name.short_name) );
1287 WideCharToMultiByte(CP_ACP, 0, full_name.short_name, -1,
1288 ofs->szPathName, sizeof(ofs->szPathName), NULL, NULL);
1289
1290 if (mode & OF_SHARE_EXCLUSIVE)
1291 /* Some InstallShield version uses OF_SHARE_EXCLUSIVE
1292 on the file <tempdir>/_ins0432._mp to determine how
1293 far installation has proceeded.
1294 _ins0432._mp is an executable and while running the
1295 application expects the open with OF_SHARE_ to fail*/
1296 /* Probable FIXME:
1297 As our loader closes the files after loading the executable,
1298 we can't find the running executable with FILE_InUse.
1299 The loader should keep the file open, as Windows does that, too.
1300 */
1301 {
1302 char *last = strrchr(full_name.long_name,'/');
1303 if (!last)
1304 last = full_name.long_name - 1;
1305 if (GetModuleHandle16(last+1))
1306 {
1307 TRACE("Denying shared open for %s\n",full_name.long_name);
1308 return HFILE_ERROR;
1309 }
1310 }
1311
1312 if (mode & OF_DELETE)
1313 {
1314 if (unlink( full_name.long_name ) == -1) goto not_found;
1315 TRACE("(%s): OF_DELETE return = OK\n", name);
1316 return 1;
1317 }
1318
1319 handle = FILE_CreateFile( full_name.long_name, access, sharing,
1320 NULL, OPEN_EXISTING, 0, 0,
1321 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY,
1322 GetDriveTypeW( full_name.short_name ) );
1323 if (!handle) goto not_found;
1324
1325 GetFileTime( handle, NULL, NULL, &filetime );
1326 FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
1327 if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
1328 {
1329 if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
1330 {
1331 CloseHandle( handle );
1332 WARN("(%s): OF_VERIFY failed\n", name );
1333 /* FIXME: what error here? */
1334 SetLastError( ERROR_FILE_NOT_FOUND );
1335 goto error;
1336 }
1337 }
1338 memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
1339
1340 success: /* We get here if the open was successful */
1341 TRACE("(%s): OK, return = %x\n", name, handle );
1342 if (win32)
1343 {
1344 hFileRet = (HFILE)handle;
1345 if (mode & OF_EXIST) /* Return the handle, but close it first */
1346 CloseHandle( handle );
1347 }
1348 else
1349 {
1350 hFileRet = Win32HandleToDosFileHandle( handle );
1351 if (hFileRet == HFILE_ERROR16) goto error;
1352 if (mode & OF_EXIST) /* Return the handle, but close it first */
1353 _lclose16( hFileRet );
1354 }
1355 return hFileRet;
1356
1357 not_found: /* We get here if the file does not exist */
1358 WARN("'%s' not found or sharing violation\n", name );
1359 SetLastError( ERROR_FILE_NOT_FOUND );
1360 /* fall through */
1361
1362 error: /* We get here if there was an error opening the file */
1363 ofs->nErrCode = GetLastError();
1364 WARN("(%s): return = HFILE_ERROR error= %d\n",
1365 name,ofs->nErrCode );
1366 return HFILE_ERROR;
1367 }
1368
1369
1370 /***********************************************************************
1371 * OpenFile (KERNEL.74)
1372 * OpenFileEx (KERNEL.360)
1373 */
1374 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
1375 {
1376 return FILE_DoOpenFile( name, ofs, mode, FALSE );
1377 }
1378
1379
1380 /***********************************************************************
1381 * OpenFile (KERNEL32.@)
1382 */
1383 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
1384 {
1385 return FILE_DoOpenFile( name, ofs, mode, TRUE );
1386 }
1387
1388
1389 /***********************************************************************
1390 * FILE_InitProcessDosHandles
1391 *
1392 * Allocates the default DOS handles for a process. Called either by
1393 * Win32HandleToDosFileHandle below or by the DOSVM stuff.
1394 */
1395 static void FILE_InitProcessDosHandles( void )
1396 {
1397 HANDLE cp = GetCurrentProcess();
1398 DuplicateHandle(cp, GetStdHandle(STD_INPUT_HANDLE), cp, &dos_handles[0],
1399 0, TRUE, DUPLICATE_SAME_ACCESS);
1400 DuplicateHandle(cp, GetStdHandle(STD_OUTPUT_HANDLE), cp, &dos_handles[1],
1401 0, TRUE, DUPLICATE_SAME_ACCESS);
1402 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[2],
1403 0, TRUE, DUPLICATE_SAME_ACCESS);
1404 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[3],
1405 0, TRUE, DUPLICATE_SAME_ACCESS);
1406 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[4],
1407 0, TRUE, DUPLICATE_SAME_ACCESS);
1408 }
1409
1410 /***********************************************************************
1411 * Win32HandleToDosFileHandle (KERNEL32.21)
1412 *
1413 * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
1414 * longer valid after this function (even on failure).
1415 *
1416 * Note: this is not exactly right, since on Win95 the Win32 handles
1417 * are on top of DOS handles and we do it the other way
1418 * around. Should be good enough though.
1419 */
1420 HFILE WINAPI Win32HandleToDosFileHandle( HANDLE handle )
1421 {
1422 int i;
1423
1424 if (!handle || (handle == INVALID_HANDLE_VALUE))
1425 return HFILE_ERROR;
1426
1427 for (i = 5; i < DOS_TABLE_SIZE; i++)
1428 if (!dos_handles[i])
1429 {
1430 dos_handles[i] = handle;
1431 TRACE("Got %d for h32 %d\n", i, handle );
1432 return (HFILE)i;
1433 }
1434 CloseHandle( handle );
1435 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1436 return HFILE_ERROR;
1437 }
1438
1439
1440 /***********************************************************************
1441 * DosFileHandleToWin32Handle (KERNEL32.20)
1442 *
1443 * Return the Win32 handle for a DOS handle.
1444 *
1445 * Note: this is not exactly right, since on Win95 the Win32 handles
1446 * are on top of DOS handles and we do it the other way
1447 * around. Should be good enough though.
1448 */
1449 HANDLE WINAPI DosFileHandleToWin32Handle( HFILE handle )
1450 {
1451 HFILE16 hfile = (HFILE16)handle;
1452 if (hfile < 5 && !dos_handles[hfile]) FILE_InitProcessDosHandles();
1453 if ((hfile >= DOS_TABLE_SIZE) || !dos_handles[hfile])
1454 {
1455 SetLastError( ERROR_INVALID_HANDLE );
1456 return INVALID_HANDLE_VALUE;
1457 }
1458 return dos_handles[hfile];
1459 }
1460
1461
1462 /***********************************************************************
1463 * DisposeLZ32Handle (KERNEL32.22)
1464 *
1465 * Note: this is not entirely correct, we should only close the
1466 * 32-bit handle and not the 16-bit one, but we cannot do
1467 * this because of the way our DOS handles are implemented.
1468 * It shouldn't break anything though.
1469 */
1470 void WINAPI DisposeLZ32Handle( HANDLE handle )
1471 {
1472 int i;
1473
1474 if (!handle || (handle == INVALID_HANDLE_VALUE)) return;
1475
1476 for (i = 5; i < DOS_TABLE_SIZE; i++)
1477 if (dos_handles[i] == handle)
1478 {
1479 dos_handles[i] = 0;
1480 CloseHandle( handle );
1481 break;
1482 }
1483 }
1484
1485
1486 /***********************************************************************
1487 * FILE_Dup2
1488 *
1489 * dup2() function for DOS handles.
1490 */
1491 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1492 {
1493 HANDLE new_handle;
1494
1495 if (hFile1 < 5 && !dos_handles[hFile1]) FILE_InitProcessDosHandles();
1496
1497 if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) || !dos_handles[hFile1])
1498 {
1499 SetLastError( ERROR_INVALID_HANDLE );
1500 return HFILE_ERROR16;
1501 }
1502 if (!DuplicateHandle( GetCurrentProcess(), dos_handles[hFile1],
1503 GetCurrentProcess(), &new_handle,
1504 0, FALSE, DUPLICATE_SAME_ACCESS ))
1505 return HFILE_ERROR16;
1506 if (dos_handles[hFile2]) CloseHandle( dos_handles[hFile2] );
1507 dos_handles[hFile2] = new_handle;
1508 return hFile2;
1509 }
1510
1511
1512 /***********************************************************************
1513 * _lclose (KERNEL.81)
1514 */
1515 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1516 {
1517 if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
1518 {
1519 SetLastError( ERROR_INVALID_HANDLE );
1520 return HFILE_ERROR16;
1521 }
1522 TRACE("%d (handle32=%d)\n", hFile, dos_handles[hFile] );
1523 CloseHandle( dos_handles[hFile] );
1524 dos_handles[hFile] = 0;
1525 return 0;
1526 }
1527
1528
1529 /***********************************************************************
1530 * _lclose (KERNEL32.@)
1531 */
1532 HFILE WINAPI _lclose( HFILE hFile )
1533 {
1534 TRACE("handle %d\n", hFile );
1535 return CloseHandle( (HANDLE)hFile ) ? 0 : HFILE_ERROR;
1536 }
1537
1538 /***********************************************************************
1539 * GetOverlappedResult (KERNEL32.@)
1540 *
1541 * Check the result of an Asynchronous data transfer from a file.
1542 *
1543 * RETURNS
1544 * TRUE on success
1545 * FALSE on failure
1546 *
1547 * If successful (and relevant) lpTransferred will hold the number of
1548 * bytes transferred during the async operation.
1549 *
1550 * BUGS
1551 *
1552 * Currently only works for WaitCommEvent, ReadFile, WriteFile
1553 * with communications ports.
1554 *
1555 */
1556 BOOL WINAPI GetOverlappedResult(
1557 HANDLE hFile, /* [in] handle of file to check on */
1558 LPOVERLAPPED lpOverlapped, /* [in/out] pointer to overlapped */
1559 LPDWORD lpTransferred, /* [in/out] number of bytes transferred */
1560 BOOL bWait /* [in] wait for the transfer to complete ? */
1561 ) {
1562 DWORD r;
1563
1564 TRACE("(%d %p %p %x)\n", hFile, lpOverlapped, lpTransferred, bWait);
1565
1566 if(lpOverlapped==NULL)
1567 {
1568 ERR("lpOverlapped was null\n");
1569 return FALSE;
1570 }
1571 if(!lpOverlapped->hEvent)
1572 {
1573 ERR("lpOverlapped->hEvent was null\n");
1574 return FALSE;
1575 }
1576
1577 if ( bWait )
1578 {
1579 do {
1580 TRACE("waiting on %p\n",lpOverlapped);
1581 r = WaitForSingleObjectEx(lpOverlapped->hEvent, INFINITE, TRUE);
1582 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1583 } while (r==STATUS_USER_APC);
1584 }
1585 else if ( lpOverlapped->Internal == STATUS_PENDING )
1586 {
1587 /* Wait in order to give APCs a chance to run. */
1588 /* This is cheating, so we must set the event again in case of success -
1589 it may be a non-manual reset event. */
1590 do {
1591 TRACE("waiting on %p\n",lpOverlapped);
1592 r = WaitForSingleObjectEx(lpOverlapped->hEvent, 0, TRUE);
1593 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1594 } while (r==STATUS_USER_APC);
1595 if ( r == WAIT_OBJECT_0 )
1596 NtSetEvent ( lpOverlapped->hEvent, NULL );
1597 }
1598
1599 if(lpTransferred)
1600 *lpTransferred = lpOverlapped->InternalHigh;
1601
1602 switch ( lpOverlapped->Internal )
1603 {
1604 case STATUS_SUCCESS:
1605 return TRUE;
1606 case STATUS_PENDING:
1607 SetLastError ( ERROR_IO_INCOMPLETE );
1608 if ( bWait ) ERR ("PENDING status after waiting!\n");
1609 return FALSE;
1610 default:
1611 SetLastError ( RtlNtStatusToDosError ( lpOverlapped->Internal ) );
1612 return FALSE;
1613 }
1614 }
1615
1616 /***********************************************************************
1617 * CancelIo (KERNEL32.@)
1618 */
1619 BOOL WINAPI CancelIo(HANDLE handle)
1620 {
1621 async_private *ovp,*t;
1622
1623 TRACE("handle = %x\n",handle);
1624
1625 for (ovp = NtCurrentTeb()->pending_list; ovp; ovp = t)
1626 {
1627 t = ovp->next;
1628 if ( ovp->handle == handle )
1629 cancel_async ( ovp );
1630 }
1631 WaitForMultipleObjectsEx(0,NULL,FALSE,1,TRUE);
1632 return TRUE;
1633 }
1634
1635 /***********************************************************************
1636 * FILE_AsyncReadService (INTERNAL)
1637 *
1638 * This function is called while the client is waiting on the
1639 * server, so we can't make any server calls here.
1640 */
1641 static void FILE_AsyncReadService(async_private *ovp)
1642 {
1643 async_fileio *fileio = (async_fileio*) ovp;
1644 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1645 int result, r;
1646 int already = lpOverlapped->InternalHigh;
1647
1648 TRACE("%p %p\n", lpOverlapped, fileio->buffer );
1649
1650 /* check to see if the data is ready (non-blocking) */
1651
1652 if ( fileio->fd_type == FD_TYPE_SOCKET )
1653 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1654 else
1655 {
1656 result = pread (ovp->fd, &fileio->buffer[already], fileio->count - already,
1657 OVERLAPPED_OFFSET (lpOverlapped) + already);
1658 if ((result < 0) && (errno == ESPIPE))
1659 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1660 }
1661
1662 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1663 {
1664 TRACE("Deferred read %d\n",errno);
1665 r = STATUS_PENDING;
1666 goto async_end;
1667 }
1668
1669 /* check to see if the transfer is complete */
1670 if(result<0)
1671 {
1672 r = FILE_GetNtStatus ();
1673 goto async_end;
1674 }
1675
1676 lpOverlapped->InternalHigh += result;
1677 TRACE("read %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1678
1679 if(lpOverlapped->InternalHigh >= fileio->count || fileio->fd_type == FD_TYPE_SOCKET )
1680 r = STATUS_SUCCESS;
1681 else
1682 r = STATUS_PENDING;
1683
1684 async_end:
1685 lpOverlapped->Internal = r;
1686 }
1687
1688 /***********************************************************************
1689 * FILE_ReadFileEx (INTERNAL)
1690 */
1691 static BOOL FILE_ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1692 LPOVERLAPPED overlapped,
1693 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1694 HANDLE hEvent)
1695 {
1696 async_fileio *ovp;
1697 int fd;
1698 int flags;
1699 enum fd_type type;
1700
1701 TRACE("file %d to buf %p num %ld %p func %p\n",
1702 hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine);
1703
1704 /* check that there is an overlapped struct */
1705 if (overlapped==NULL)
1706 {
1707 SetLastError(ERROR_INVALID_PARAMETER);
1708 return FALSE;
1709 }
1710
1711 fd = FILE_GetUnixHandleType ( hFile, GENERIC_READ, &type, &flags);
1712 if ( fd < 0 )
1713 {
1714 WARN ( "Couldn't get FD\n" );
1715 return FALSE;
1716 }
1717
1718 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1719 if(!ovp)
1720 {
1721 TRACE("HeapAlloc Failed\n");
1722 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1723 goto error;
1724 }
1725
1726 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1727 ovp->async.handle = hFile;
1728 ovp->async.fd = fd;
1729 ovp->async.type = ASYNC_TYPE_READ;
1730 ovp->async.func = FILE_AsyncReadService;
1731 ovp->async.event = hEvent;
1732 ovp->lpOverlapped = overlapped;
1733 ovp->count = bytesToRead;
1734 ovp->completion_func = lpCompletionRoutine;
1735 ovp->buffer = buffer;
1736 ovp->fd_type = type;
1737
1738 return !register_new_async (&ovp->async);
1739
1740 error:
1741 close (fd);
1742 return FALSE;
1743
1744 }
1745
1746 /***********************************************************************
1747 * ReadFileEx (KERNEL32.@)
1748 */
1749 BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1750 LPOVERLAPPED overlapped,
1751 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1752 {
1753 overlapped->InternalHigh = 0;
1754 return FILE_ReadFileEx(hFile,buffer,bytesToRead,overlapped,lpCompletionRoutine, INVALID_HANDLE_VALUE);
1755 }
1756
1757 static BOOL FILE_TimeoutRead(HANDLE hFile, LPVOID buffer, DWORD bytesToRead, LPDWORD bytesRead)
1758 {
1759 OVERLAPPED ov;
1760 BOOL r = FALSE;
1761
1762 TRACE("%d %p %ld %p\n", hFile, buffer, bytesToRead, bytesRead );
1763
1764 ZeroMemory(&ov, sizeof (OVERLAPPED));
1765 if(STATUS_SUCCESS==NtCreateEvent(&ov.hEvent, SYNCHRONIZE, NULL, 0, 0))
1766 {
1767 if(FILE_ReadFileEx(hFile, buffer, bytesToRead, &ov, NULL, ov.hEvent))
1768 {
1769 r = GetOverlappedResult(hFile, &ov, bytesRead, TRUE);
1770 }
1771 }
1772 CloseHandle(ov.hEvent);
1773 return r;
1774 }
1775
1776 /***********************************************************************
1777 * ReadFile (KERNEL32.@)
1778 */
1779 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1780 LPDWORD bytesRead, LPOVERLAPPED overlapped )
1781 {
1782 int unix_handle, result, flags;
1783 enum fd_type type;
1784
1785 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToRead,
1786 bytesRead, overlapped );
1787
1788 if (bytesRead) *bytesRead = 0; /* Do this before anything else */
1789 if (!bytesToRead) return TRUE;
1790
1791 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_READ, &type, &flags );
1792
1793 if (flags & FD_FLAG_OVERLAPPED)
1794 {
1795 if (unix_handle == -1) return FALSE;
1796 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
1797 {
1798 TRACE("Overlapped not specified or invalid event flag\n");
1799 close(unix_handle);
1800 SetLastError(ERROR_INVALID_PARAMETER);
1801 return FALSE;
1802 }
1803
1804 close(unix_handle);
1805 overlapped->InternalHigh = 0;
1806
1807 if(!FILE_ReadFileEx(hFile, buffer, bytesToRead, overlapped, NULL, overlapped->hEvent))
1808 return FALSE;
1809
1810 if ( !GetOverlappedResult (hFile, overlapped, bytesRead, FALSE) )
1811 {
1812 if ( GetLastError() == ERROR_IO_INCOMPLETE )
1813 SetLastError ( ERROR_IO_PENDING );
1814 return FALSE;
1815 }
1816
1817 return TRUE;
1818 }
1819 if (flags & FD_FLAG_TIMEOUT)
1820 {
1821 close(unix_handle);
1822 return FILE_TimeoutRead(hFile, buffer, bytesToRead, bytesRead);
1823 }
1824 switch(type)
1825 {
1826 case FD_TYPE_SMB:
1827 return SMB_ReadFile(hFile, buffer, bytesToRead, bytesRead, NULL);
1828
1829 case FD_TYPE_CONSOLE:
1830 return FILE_ReadConsole(hFile, buffer, bytesToRead, bytesRead, NULL);
1831
1832 case FD_TYPE_DEFAULT:
1833 /* normal unix files */
1834 if (unix_handle == -1) return FALSE;
1835 if (overlapped)
1836 {
1837 DWORD highOffset = overlapped->OffsetHigh;
1838 if ( (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, overlapped->Offset,
1839 &highOffset, FILE_BEGIN)) &&
1840 (GetLastError() != NO_ERROR) )
1841 {
1842 close(unix_handle);
1843 return FALSE;
1844 }
1845 }
1846 break;
1847
1848 default:
1849 if (unix_handle == -1)
1850 return FALSE;
1851 }
1852
1853 if(overlapped)
1854 {
1855 off_t offset = OVERLAPPED_OFFSET(overlapped);
1856 if(lseek(unix_handle, offset, SEEK_SET) == -1)
1857 {
1858 close(unix_handle);
1859 SetLastError(ERROR_INVALID_PARAMETER);
1860 return FALSE;
1861 }
1862 }
1863
1864 /* code for synchronous reads */
1865 while ((result = read( unix_handle, buffer, bytesToRead )) == -1)
1866 {
1867 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1868 if ((errno == EFAULT) && !IsBadWritePtr( buffer, bytesToRead )) continue;
1869 FILE_SetDosError();
1870 break;
1871 }
1872 close( unix_handle );
1873 if (result == -1) return FALSE;
1874 if (bytesRead) *bytesRead = result;
1875 return TRUE;
1876 }
1877
1878
1879 /***********************************************************************
1880 * FILE_AsyncWriteService (INTERNAL)
1881 *
1882 * This function is called while the client is waiting on the
1883 * server, so we can't make any server calls here.
1884 */
1885 static void FILE_AsyncWriteService(struct async_private *ovp)
1886 {
1887 async_fileio *fileio = (async_fileio *) ovp;
1888 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1889 int result, r;
1890 int already = lpOverlapped->InternalHigh;
1891
1892 TRACE("(%p %p)\n",lpOverlapped,fileio->buffer);
1893
1894 /* write some data (non-blocking) */
1895
1896 if ( fileio->fd_type == FD_TYPE_SOCKET )
1897 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1898 else
1899 {
1900 result = pwrite(ovp->fd, &fileio->buffer[already], fileio->count - already,
1901 OVERLAPPED_OFFSET (lpOverlapped) + already);
1902 if ((result < 0) && (errno == ESPIPE))
1903 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1904 }
1905
1906 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1907 {
1908 r = STATUS_PENDING;
1909 goto async_end;
1910 }
1911
1912 /* check to see if the transfer is complete */
1913 if(result<0)
1914 {
1915 r = FILE_GetNtStatus ();
1916 goto async_end;
1917 }
1918
1919 lpOverlapped->InternalHigh += result;
1920
1921 TRACE("wrote %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1922
1923 if(lpOverlapped->InternalHigh < fileio->count)
1924 r = STATUS_PENDING;
1925 else
1926 r = STATUS_SUCCESS;
1927
1928 async_end:
1929 lpOverlapped->Internal = r;
1930 }
1931
1932 /***********************************************************************
1933 * FILE_WriteFileEx
1934 */
1935 static BOOL FILE_WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1936 LPOVERLAPPED overlapped,
1937 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1938 HANDLE hEvent)
1939 {
1940 async_fileio *ovp;
1941 int fd;
1942 int flags;
1943 enum fd_type type;
1944
1945 TRACE("file %d to buf %p num %ld %p func %p handle %d\n",
1946 hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, hEvent);
1947
1948 if (overlapped == NULL)
1949 {
1950 SetLastError(ERROR_INVALID_PARAMETER);
1951 return FALSE;
1952 }
1953
1954 fd = FILE_GetUnixHandleType ( hFile, GENERIC_WRITE, &type, &flags );
1955 if ( fd < 0 )
1956 {
1957 TRACE( "Couldn't get FD\n" );
1958 return FALSE;
1959 }
1960
1961 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1962 if(!ovp)
1963 {
1964 TRACE("HeapAlloc Failed\n");
1965 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1966 goto error;
1967 }
1968
1969 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1970 ovp->async.handle = hFile;
1971 ovp->async.fd = fd;
1972 ovp->async.type = ASYNC_TYPE_WRITE;
1973 ovp->async.func = FILE_AsyncWriteService;
1974 ovp->lpOverlapped = overlapped;
1975 ovp->async.event = hEvent;
1976 ovp->buffer = (LPVOID) buffer;
1977 ovp->count = bytesToWrite;
1978 ovp->completion_func = lpCompletionRoutine;
1979 ovp->fd_type = type;
1980
1981 return !register_new_async (&ovp->async);
1982
1983 error:
1984 close (fd);
1985 return FALSE;
1986 }
1987
1988 /***********************************************************************
1989 * WriteFileEx (KERNEL32.@)
1990 */
1991 BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1992 LPOVERLAPPED overlapped,
1993 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1994 {
1995 overlapped->InternalHigh = 0;
1996
1997 return FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, INVALID_HANDLE_VALUE);
1998 }
1999
2000 /***********************************************************************
2001 * WriteFile (KERNEL32.@)
2002 */
2003 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
2004 LPDWORD bytesWritten, LPOVERLAPPED overlapped )
2005 {
2006 int unix_handle, result, flags;
2007 enum fd_type type;
2008
2009 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToWrite,
2010 bytesWritten, overlapped );
2011
2012 if (bytesWritten) *bytesWritten = 0; /* Do this before anything else */
2013 if (!bytesToWrite) return TRUE;
2014
2015 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_WRITE, &type, &flags );
2016
2017 if (flags & FD_FLAG_OVERLAPPED)
2018 {
2019 if (unix_handle == -1) return FALSE;
2020 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
2021 {
2022 TRACE("Overlapped not specified or invalid event flag\n");
2023 close(unix_handle);
2024 SetLastError(ERROR_INVALID_PARAMETER);
2025 return FALSE;
2026 }
2027
2028 close(unix_handle);
2029 overlapped->InternalHigh = 0;
2030
2031 if(!FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, NULL, overlapped->hEvent))
2032 return FALSE;
2033
2034 if ( !GetOverlappedResult (hFile, overlapped, bytesWritten, FALSE) )
2035 {
2036 if ( GetLastError() == ERROR_IO_INCOMPLETE )
2037 SetLastError ( ERROR_IO_PENDING );
2038 return FALSE;
2039 }
2040
2041 return TRUE;
2042 }
2043
2044 switch(type)
2045 {
2046 case FD_TYPE_CONSOLE:
2047 TRACE("%d %s %ld %p %p\n", hFile, debugstr_an(buffer, bytesToWrite), bytesToWrite,
2048 bytesWritten, overlapped );
2049 return FILE_WriteConsole(hFile, buffer, bytesToWrite, bytesWritten, NULL);
2050
2051 case FD_TYPE_DEFAULT:
2052 if (unix_handle == -1) return FALSE;
2053
2054 if(overlapped)
2055 {
2056 DWORD highOffset = overlapped->OffsetHigh;
2057 if ( (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, overlapped->Offset,
2058 &highOffset, FILE_BEGIN)) &&
2059 (GetLastError() != NO_ERROR) )
2060 {
2061 close(unix_handle);
2062 return FALSE;
2063 }
2064 }
2065 break;
2066
2067 default:
2068 if (unix_handle == -1)
2069 return FALSE;
2070 if (overlapped)
2071 {
2072 close(unix_handle);
2073 SetLastError(ERROR_INVALID_PARAMETER);
2074 return FALSE;
2075 }
2076 break;
2077 }
2078
2079 if(overlapped)
2080 {
2081 off_t offset = OVERLAPPED_OFFSET(overlapped);
2082 if(lseek(unix_handle, offset, SEEK_SET) == -1)
2083 {
2084 close(unix_handle);
2085 SetLastError(ERROR_INVALID_PARAMETER);
2086 return FALSE;
2087 }
2088 }
2089
2090 /* synchronous file write */
2091 while ((result = write( unix_handle, buffer, bytesToWrite )) == -1)
2092 {
2093 if ((errno == EAGAIN) || (errno == EINTR)) continue;
2094 if ((errno == EFAULT) && !IsBadReadPtr( buffer, bytesToWrite )) continue;
2095 if (errno == ENOSPC)
2096 SetLastError( ERROR_DISK_FULL );
2097 else
2098 FILE_SetDosError();
2099 break;
2100 }
2101 close( unix_handle );
2102 if (result == -1) return FALSE;
2103 if (bytesWritten) *bytesWritten = result;
2104 return TRUE;
2105 }
2106
2107
2108 /***********************************************************************
2109 * _hread (KERNEL.349)
2110 */
2111 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
2112 {
2113 LONG maxlen;
2114
2115 TRACE("%d %08lx %ld\n",
2116 hFile, (DWORD)buffer, count );
2117
2118 /* Some programs pass a count larger than the allocated buffer */
2119 maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
2120 if (count > maxlen) count = maxlen;
2121 return _lread((HFILE)DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
2122 }
2123
2124
2125 /***********************************************************************
2126 * _lread (KERNEL.82)
2127 */
2128 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
2129 {
2130 return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
2131 }
2132
2133
2134 /***********************************************************************
2135 * _lread (KERNEL32.@)
2136 */
2137 UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
2138 {
2139 DWORD result;
2140 if (!ReadFile( (HANDLE)handle, buffer, count, &result, NULL )) return -1;
2141 return result;
2142 }
2143
2144
2145 /***********************************************************************
2146 * _lread16 (KERNEL.82)
2147 */
2148 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
2149 {
2150 return (UINT16)_lread((HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
2151 }
2152
2153
2154 /***********************************************************************
2155 * _lcreat (KERNEL.83)
2156 */
2157 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
2158 {
2159 return Win32HandleToDosFileHandle( (HANDLE)_lcreat( path, attr ) );
2160 }
2161
2162
2163 /***********************************************************************
2164 * _lcreat (KERNEL32.@)
2165 */
2166 HFILE WINAPI _lcreat( LPCSTR path, INT attr )
2167 {
2168 /* Mask off all flags not explicitly allowed by the doc */
2169 attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
2170 TRACE("%s %02x\n", path, attr );
2171 return (HFILE)CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
2172 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2173 CREATE_ALWAYS, attr, 0 );
2174 }
2175
2176
2177 /***********************************************************************
2178 * SetFilePointer (KERNEL32.@)
2179 */
2180 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
2181 DWORD method )
2182 {
2183 DWORD ret = INVALID_SET_FILE_POINTER;
2184
2185 TRACE("handle %d offset %ld high %ld origin %ld\n",
2186 hFile, distance, highword?*highword:0, method );
2187
2188 SERVER_START_REQ( set_file_pointer )
2189 {
2190 req->handle = hFile;
2191 req->low = distance;
2192 req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
2193 /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
2194 req->whence = method;
2195 SetLastError( 0 );
2196 if (!wine_server_call_err( req ))
2197 {
2198 ret = reply->new_low;
2199 if (highword) *highword = reply->new_high;
2200 }
2201 }
2202 SERVER_END_REQ;
2203 return ret;
2204 }
2205
2206
2207 /***********************************************************************
2208 * _llseek (KERNEL.84)
2209 *
2210 * FIXME:
2211 * Seeking before the start of the file should be allowed for _llseek16,
2212 * but cause subsequent I/O operations to fail (cf. interrupt list)
2213 *
2214 */
2215 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
2216 {
2217 return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
2218 }
2219
2220
2221 /***********************************************************************
2222 * _llseek (KERNEL32.@)
2223 */
2224 LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
2225 {
2226 return SetFilePointer( (HANDLE)hFile, lOffset, NULL, nOrigin );
2227 }
2228
2229
2230 /***********************************************************************
2231 * _lopen (KERNEL.85)
2232 */
2233 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
2234 {
2235 return Win32HandleToDosFileHandle( (HANDLE)_lopen( path, mode ) );
2236 }
2237
2238
2239 /***********************************************************************
2240 * _lopen (KERNEL32.@)
2241 */
2242 HFILE WINAPI _lopen( LPCSTR path, INT mode )
2243 {
2244 DWORD access, sharing;
2245
2246 TRACE("('%s',%04x)\n", path, mode );
2247 FILE_ConvertOFMode( mode, &access, &sharing );
2248 return (HFILE)CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, 0 );
2249 }
2250
2251
2252 /***********************************************************************
2253 * _lwrite (KERNEL.86)
2254 */
2255 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
2256 {
2257 return (UINT16)_hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
2258 }
2259
2260 /***********************************************************************
2261 * _lwrite (KERNEL32.@)
2262 */
2263 UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
2264 {
2265 return (UINT)_hwrite( hFile, buffer, (LONG)count );
2266 }
2267
2268
2269 /***********************************************************************
2270 * _hread16 (KERNEL.349)
2271 */
2272 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
2273 {
2274 return _lread( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
2275 }
2276
2277
2278 /***********************************************************************
2279 * _hread (KERNEL32.@)
2280 */
2281 LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
2282 {
2283 return _lread( hFile, buffer, count );
2284 }
2285
2286
2287 /***********************************************************************
2288 * _hwrite (KERNEL.350)
2289 */
2290 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
2291 {
2292 return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
2293 }
2294
2295
2296 /***********************************************************************
2297 * _hwrite (KERNEL32.@)
2298 *
2299 * experimentation yields that _lwrite:
2300 * o truncates the file at the current position with
2301 * a 0 len write
2302 * o returns 0 on a 0 length write
2303 * o works with console handles
2304 *
2305 */
2306 LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
2307 {
2308 DWORD result;
2309
2310 TRACE("%d %p %ld\n", handle, buffer, count );
2311
2312 if (!count)
2313 {
2314 /* Expand or truncate at current position */
2315 if (!SetEndOfFile( (HANDLE)handle )) return HFILE_ERROR;
2316 return 0;
2317 }
2318 if (!WriteFile( (HANDLE)handle, buffer, count, &result, NULL ))
2319 return HFILE_ERROR;
2320 return result;
2321 }
2322
2323
2324 /***********************************************************************
2325 * SetHandleCount (KERNEL.199)
2326 */
2327 UINT16 WINAPI SetHandleCount16( UINT16 count )
2328 {
2329 return SetHandleCount( count );
2330 }
2331
2332
2333 /*************************************************************************
2334 * SetHandleCount (KERNEL32.@)
2335 */
2336 UINT WINAPI SetHandleCount( UINT count )
2337 {
2338 return min( 256, count );
2339 }
2340
2341
2342 /***********************************************************************
2343 * FlushFileBuffers (KERNEL32.@)
2344 */
2345 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
2346 {
2347 BOOL ret;
2348 SERVER_START_REQ( flush_file )
2349 {
2350 req->handle = hFile;
2351 ret = !wine_server_call_err( req );
2352 }
2353 SERVER_END_REQ;
2354 return ret;
2355 }
2356
2357
2358 /**************************************************************************
2359 * SetEndOfFile (KERNEL32.@)
2360 */
2361 BOOL WINAPI SetEndOfFile( HANDLE hFile )
2362 {
2363 BOOL ret;
2364 SERVER_START_REQ( truncate_file )
2365 {
2366 req->handle = hFile;
2367 ret = !wine_server_call_err( req );
2368 }
2369 SERVER_END_REQ;
2370 return ret;
2371 }
2372
2373
2374 /***********************************************************************
2375 * DeleteFile (KERNEL.146)
2376 */
2377 BOOL16 WINAPI DeleteFile16( LPCSTR path )
2378 {
2379 return DeleteFileA( path );
2380 }
2381
2382
2383 /***********************************************************************
2384 * DeleteFileW (KERNEL32.@)
2385 */
2386 BOOL WINAPI DeleteFileW( LPCWSTR path )
2387 {
2388 DOS_FULL_NAME full_name;
2389 HANDLE hFile;
2390
2391 if (!path)
2392 {
2393 SetLastError(ERROR_INVALID_PARAMETER);
2394 return FALSE;
2395 }
2396 TRACE("%s\n", debugstr_w(path) );
2397
2398 if (!*path)
2399 {
2400 ERR("Empty path passed\n");
2401 return FALSE;
2402 }
2403 if (DOSFS_GetDevice( path ))
2404 {
2405 WARN("cannot remove DOS device %s!\n", debugstr_w(path));
2406 SetLastError( ERROR_FILE_NOT_FOUND );
2407 return FALSE;
2408 }
2409
2410 if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
2411
2412 /* check if we are allowed to delete the source */
2413 hFile = FILE_CreateFile( full_name.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2414 NULL, OPEN_EXISTING, 0, 0, TRUE,
2415 GetDriveTypeW( full_name.short_name ) );
2416 if (!hFile) return FALSE;
2417
2418 if (unlink( full_name.long_name ) == -1)
2419 {
2420 FILE_SetDosError();
2421 CloseHandle(hFile);
2422 return FALSE;
2423 }
2424 CloseHandle(hFile);
2425 return TRUE;
2426 }
2427
2428
2429 /***********************************************************************
2430 * DeleteFileA (KERNEL32.@)
2431 */
2432 BOOL WINAPI DeleteFileA( LPCSTR path )
2433 {
2434 UNICODE_STRING pathW;
2435 BOOL ret = FALSE;
2436
2437 if (!path)
2438 {
2439 SetLastError(ERROR_INVALID_PARAMETER);
2440 return FALSE;
2441 }
2442
2443 if (RtlCreateUnicodeStringFromAsciiz(&pathW, path))
2444 {
2445 ret = DeleteFileW(pathW.Buffer);
2446 RtlFreeUnicodeString(&pathW);
2447 }
2448 else
2449 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2450 return ret;
2451 }
2452
2453
2454 /***********************************************************************
2455 * GetFileType (KERNEL32.@)
2456 */
2457 DWORD WINAPI GetFileType( HANDLE hFile )
2458 {
2459 DWORD ret = FILE_TYPE_UNKNOWN;
2460 SERVER_START_REQ( get_file_info )
2461 {
2462 req->handle = hFile;
2463 if (!wine_server_call_err( req )) ret = reply->type;
2464 }
2465 SERVER_END_REQ;
2466 return ret;
2467 }
2468
2469
2470 /* check if a file name is for an executable file (.exe or .com) */
2471 inline static BOOL is_executable( const char *name )
2472 {
2473 int len = strlen(name);
2474
2475 if (len < 4) return FALSE;
2476 return (!strcasecmp( name + len - 4, ".exe" ) ||
2477 !strcasecmp( name + len - 4, ".com" ));
2478 }
2479
2480
2481 /***********************************************************************
2482 * FILE_AddBootRenameEntry
2483 *
2484 * Adds an entry to the registry that is loaded when windows boots and
2485 * checks if there are some files to be removed or renamed/moved.
2486 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
2487 * non-NULL then the file is moved, otherwise it is deleted. The
2488 * entry of the registrykey is always appended with two zero
2489 * terminated strings. If <fn2> is NULL then the second entry is
2490 * simply a single 0-byte. Otherwise the second filename goes
2491 * there. The entries are prepended with \??\ before the path and the
2492 * second filename gets also a '!' as the first character if
2493 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
2494 * 0-byte follows to indicate the end of the strings.
2495 * i.e.:
2496 * \??\D:\test\file1[0]
2497 * !\??\D:\test\file1_renamed[0]
2498 * \??\D:\Test|delete[0]
2499 * [0] <- file is to be deleted, second string empty
2500 * \??\D:\test\file2[0]
2501 * !\??\D:\test\file2_renamed[0]
2502 * [0] <- indicates end of strings
2503 *
2504 * or:
2505 * \??\D:\test\file1[0]
2506 * !\??\D:\test\file1_renamed[0]
2507 * \??\D:\Test|delete[0]
2508 * [0] <- file is to be deleted, second string empty
2509 * [0] <- indicates end of strings
2510 *
2511 */
2512 static BOOL FILE_AddBootRenameEntry( LPCWSTR fn1, LPCWSTR fn2, DWORD flags )
2513 {
2514 static const WCHAR PreString[] = {'\\','?','?','\\',0};
2515 static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
2516 'F','i','l','e','R','e','n','a','m','e',
2517 'O','p','e','r','a','t','i','o','n','s',0};
2518 static const WCHAR SessionW[] = {'M','a','c','h','i','n','e','\\',
2519 'S','y','s','t','e','m','\\',
2520 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
2521 'C','o','n','t','r','o','l','\\',
2522 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
2523 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
2524
2525 OBJECT_ATTRIBUTES attr;
2526 UNICODE_STRING nameW;
2527 KEY_VALUE_PARTIAL_INFORMATION *info;
2528 BOOL rc = FALSE;
2529 HKEY Reboot = 0;
2530 DWORD len0, len1, len2;
2531 DWORD DataSize = 0;
2532 BYTE *Buffer = NULL;
2533 WCHAR *p;
2534
2535 attr.Length = sizeof(attr);
2536 attr.RootDirectory = 0;
2537 attr.ObjectName = &nameW;
2538 attr.Attributes = 0;
2539 attr.SecurityDescriptor = NULL;
2540 attr.SecurityQualityOfService = NULL;
2541 RtlInitUnicodeString( &nameW, SessionW );
2542
2543 if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
2544 {
2545 WARN("Error creating key for reboot managment [%s]\n",
2546 "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
2547 return FALSE;
2548 }
2549
2550 len0 = strlenW(PreString);
2551 len1 = strlenW(fn1) + len0 + 1;
2552 if (fn2)
2553 {
2554 len2 = strlenW(fn2) + len0 + 1;
2555 if (flags & MOVEFILE_REPLACE_EXISTING) len2++; /* Plus 1 because of the leading '!' */
2556 }
2557 else len2 = 1; /* minimum is the 0 characters for the empty second string */
2558
2559 /* convert characters to bytes */
2560 len0 *= sizeof(WCHAR);
2561 len1 *= sizeof(WCHAR);
2562 len2 *= sizeof(WCHAR);
2563
2564 RtlInitUnicodeString( &nameW, ValueName );
2565
2566 /* First we check if the key exists and if so how many bytes it already contains. */
2567 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
2568 NULL, 0, &DataSize ) == STATUS_BUFFER_OVERFLOW)
2569 {
2570 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
2571 goto Quit;
2572 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
2573 Buffer, DataSize, &DataSize )) goto Quit;
2574 info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
2575 if (info->Type != REG_MULTI_SZ) goto Quit;
2576 if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
2577 }
2578 else
2579 {
2580 DataSize = info_size;
2581 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
2582 goto Quit;
2583 }
2584
2585 p = (WCHAR *)(Buffer + DataSize);
2586 strcpyW( p, PreString );
2587 strcatW( p, fn1 );
2588 DataSize += len1;
2589 if (fn2)
2590 {
2591 p = (WCHAR *)(Buffer + DataSize);
2592 if (flags & MOVEFILE_REPLACE_EXISTING)
2593 *p++ = '!';
2594 strcpyW( p, PreString );
2595 strcatW( p, fn2 );
2596 DataSize += len2;
2597 }
2598 else
2599 {
2600 p = (WCHAR *)(Buffer + DataSize);
2601 *p = 0;
2602 DataSize += sizeof(WCHAR);
2603 }
2604
2605 /* add final null */
2606 p = (WCHAR *)(Buffer + DataSize);
2607 *p = 0;
2608 DataSize += sizeof(WCHAR);
2609
2610 rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
2611
2612 Quit:
2613 if (Reboot) NtClose(Reboot);
2614 if (Buffer) HeapFree( GetProcessHeap(), 0, Buffer );
2615 return(rc);
2616 }
2617
2618
2619 /**************************************************************************
2620 * MoveFileExW (KERNEL32.@)
2621 */
2622 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
2623 {
2624 DOS_FULL_NAME full_name1, full_name2;
2625 HANDLE hFile;
2626 DWORD attr = INVALID_FILE_ATTRIBUTES;
2627
2628 TRACE("(%s,%s,%04lx)\n", debugstr_w(fn1), debugstr_w(fn2), flag);
2629
2630 /* FIXME: <Gerhard W. Gruber>sparhawk@gmx.at
2631 In case of W9x and lesser this function should return 120 (ERROR_CALL_NOT_IMPLEMENTED)
2632 to be really compatible. Most programs wont have any problems though. In case
2633 you encounter one, this is what you should return here. I don't know what's up
2634 with NT 3.5. Is this function available there or not?
2635 Does anybody really care about 3.5? :)
2636 */
2637
2638 /* Filename1 has to be always set to a valid path. Filename2 may be NULL
2639 if the source file has to be deleted.
2640 */
2641 if (!fn1) {
2642 SetLastError(ERROR_INVALID_PARAMETER);
2643 return FALSE;
2644 }
2645
2646 /* This function has to be run through in order to process the name properly.
2647 If the BOOTDELAY flag is set, the file doesn't need to exist though. At least
2648 that is the behaviour on NT 4.0. The operation accepts the filenames as
2649 they are given but it can't reply with a reasonable returncode. Success
2650 means in that case success for entering the values into the registry.
2651 */
2652 if(!DOSFS_GetFullName( fn1, TRUE, &full_name1 ))
2653 {
2654 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2655 return FALSE;
2656 }
2657
2658 if (fn2) /* !fn2 means delete fn1 */
2659 {
2660 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
2661 {
2662 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2663 {
2664 /* target exists, check if we may overwrite */
2665 if (!(flag & MOVEFILE_REPLACE_EXISTING))
2666 {
2667 SetLastError( ERROR_FILE_EXISTS );
2668 return FALSE;
2669 }
2670 }
2671 }
2672 else
2673 {
2674 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 ))
2675 {
2676 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2677 return FALSE;
2678 }
2679 }
2680
2681 /* Source name and target path are valid */
2682
2683 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2684 {
2685 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2686 Perhaps we should queue these command and execute it
2687 when exiting... What about using on_exit(2)
2688 */
2689 FIXME("Please move existing file %s to file %s when Wine has finished\n",
2690 debugstr_w(fn1), debugstr_w(fn2));
2691 return FILE_AddBootRenameEntry( fn1, fn2, flag );
2692 }
2693
2694 attr = GetFileAttributesW( fn1 );
2695 if ( attr == INVALID_FILE_ATTRIBUTES ) return FALSE;
2696
2697 /* check if we are allowed to rename the source */
2698 hFile = FILE_CreateFile( full_name1.long_name, 0, 0,
2699 NULL, OPEN_EXISTING, 0, 0, TRUE,
2700 GetDriveTypeW( full_name1.short_name ) );
2701 if (!hFile)
2702 {
2703 if (GetLastError() != ERROR_ACCESS_DENIED) return FALSE;
2704 if ( !(attr & FILE_ATTRIBUTE_DIRECTORY) ) return FALSE;
2705 /* if it's a directory we can continue */
2706 }
2707 else CloseHandle(hFile);
2708
2709 /* check, if we are allowed to delete the destination,
2710 ** (but the file not being there is fine) */
2711 hFile = FILE_CreateFile( full_name2.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2712 NULL, OPEN_EXISTING, 0, 0, TRUE,
2713 GetDriveTypeW( full_name2.short_name ) );
2714 if(!hFile && GetLastError() != ERROR_FILE_NOT_FOUND) return FALSE;
2715 CloseHandle(hFile);
2716
2717 if (full_name1.drive != full_name2.drive)
2718 {
2719 if (!(flag & MOVEFILE_COPY_ALLOWED))
2720 {
2721 SetLastError( ERROR_NOT_SAME_DEVICE );
2722 return FALSE;
2723 }
2724 else if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2725 {
2726 /* Strange, but that's what Windows returns */
2727 SetLastError ( ERROR_ACCESS_DENIED );
2728 return FALSE;
2729 }
2730 }
2731 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
2732 /* Try copy/delete unless it's a directory. */
2733 /* FIXME: This does not handle the (unlikely) case that the two locations
2734 are on the same Wine drive, but on different Unix file systems. */
2735 {
2736 if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2737 {
2738 FILE_SetDosError();
2739 return FALSE;
2740 }
2741 else
2742 {
2743 if ( ! CopyFileW( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) ))
2744 return FALSE;
2745 if ( ! DeleteFileW ( fn1 ) )
2746 return FALSE;
2747 }
2748 }
2749 if (is_executable( full_name1.long_name ) != is_executable( full_name2.long_name ))
2750 {
2751 struct stat fstat;
2752 if (stat( full_name2.long_name, &fstat ) != -1)
2753 {
2754 if (is_executable( full_name2.long_name ))
2755 /* set executable bit where read bit is set */
2756 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
2757 else
2758 fstat.st_mode &= ~0111;
2759 chmod( full_name2.long_name, fstat.st_mode );
2760 }
2761 }
2762 return TRUE;
2763 }
2764 else /* fn2 == NULL means delete source */
2765 {
2766 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2767 {
2768 if (flag & MOVEFILE_COPY_ALLOWED) {
2769 WARN("Illegal flag\n");
2770 SetLastError( ERROR_GEN_FAILURE );
2771 return FALSE;
2772 }
2773 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2774 Perhaps we should queue these command and execute it
2775 when exiting... What about using on_exit(2)
2776 */
2777 FIXME("Please delete file %s when Wine has finished\n", debugstr_w(fn1));
2778 return FILE_AddBootRenameEntry( fn1, NULL, flag );
2779 }
2780
2781 if (unlink( full_name1.long_name ) == -1)
2782 {
2783 FILE_SetDosError();
2784 return FALSE;
2785 }
2786 return TRUE; /* successfully deleted */
2787 }
2788 }
2789
2790 /**************************************************************************
2791 * MoveFileExA (KERNEL32.@)
2792 */
2793 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
2794 {
2795 UNICODE_STRING fn1W, fn2W;
2796 BOOL ret;
2797
2798 if (!fn1)
2799 {
2800 SetLastError(ERROR_INVALID_PARAMETER);
2801 return FALSE;
2802 }
2803
2804 RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
2805 if (fn2) RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
2806 else fn2W.Buffer = NULL;
2807
2808 ret = MoveFileExW( fn1W.Buffer, fn2W.Buffer, flag );
2809
2810 RtlFreeUnicodeString(&fn1W);
2811 RtlFreeUnicodeString(&fn2W);
2812 return ret;
2813 }
2814
2815
2816 /**************************************************************************
2817 * MoveFileW (KERNEL32.@)
2818 *
2819 * Move file or directory
2820 */
2821 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
2822 {
2823 DOS_FULL_NAME full_name1, full_name2;
2824 struct stat fstat;
2825
2826 if (!fn1 || !fn2)
2827 {
2828 SetLastError(ERROR_INVALID_PARAMETER);
2829 return FALSE;
2830 }
2831
2832 TRACE("(%s,%s)\n", debugstr_w(fn1), debugstr_w(fn2) );
2833
2834 if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
2835 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) {
2836 /* The new name must not already exist */
2837 SetLastError(ERROR_ALREADY_EXISTS);
2838 return FALSE;
2839 }
2840 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
2841
2842 if (full_name1.drive == full_name2.drive) /* move */
2843 return MoveFileExW( fn1, fn2, MOVEFILE_COPY_ALLOWED );
2844
2845 /* copy */
2846 if (stat( full_name1.long_name, &fstat ))
2847 {
2848 WARN("Invalid source file %s\n",
2849 full_name1.long_name);
2850 FILE_SetDosError();
2851 return FALSE;
2852 }
2853 if (S_ISDIR(fstat.st_mode)) {
2854 /* No Move for directories across file systems */
2855 /* FIXME: Use right error code */
2856 SetLastError( ERROR_GEN_FAILURE );
2857 return FALSE;
2858 }
2859 return CopyFileW(fn1, fn2, TRUE); /*fail, if exist */
2860 }
2861
2862
2863 /**************************************************************************
2864 * MoveFileA (KERNEL32.@)
2865 */
2866 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
2867 {
2868 UNICODE_STRING fn1W, fn2W;
2869 BOOL ret;
2870
2871 if (!fn1 || !fn2)
2872 {
2873 SetLastError(ERROR_INVALID_PARAMETER);
2874 return FALSE;
2875 }
2876
2877 RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
2878 RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
2879
2880 ret = MoveFileW( fn1W.Buffer, fn2W.Buffer );
2881
2882 RtlFreeUnicodeString(&fn1W);
2883 RtlFreeUnicodeString(&fn2W);
2884 return ret;
2885 }
2886
2887
2888 /**************************************************************************
2889 * CopyFileW (KERNEL32.@)
2890 */
2891 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
2892 {
2893 HANDLE h1, h2;
2894 BY_HANDLE_FILE_INFORMATION info;
2895 DWORD count;
2896 BOOL ret = FALSE;
2897 char buffer[2048];
2898
2899 if (!source || !dest)
2900 {
2901 SetLastError(ERROR_INVALID_PARAMETER);
2902 return FALSE;
2903 }
2904
2905 TRACE("%s -> %s\n", debugstr_w(source), debugstr_w(dest));
2906
2907 if ((h1 = CreateFileW(source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
2908 NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
2909 {
2910 WARN("Unable to open source %s\n", debugstr_w(source));
2911 return FALSE;
2912 }
2913
2914 if (!GetFileInformationByHandle( h1, &info ))
2915 {
2916 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
2917 CloseHandle( h1 );
2918 return FALSE;
2919 }
2920
2921 if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2922 fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
2923 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
2924 {
2925 WARN("Unable to open dest %s\n", debugstr_w(dest));
2926 CloseHandle( h1 );
2927 return FALSE;
2928 }
2929
2930 while (ReadFile( h1, buffer, sizeof(buffer), &count, NULL ) && count)
2931 {
2932 char *p = buffer;
2933 while (count != 0)
2934 {
2935 DWORD res;
2936 if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
2937 p += res;
2938 count -= res;
2939 }
2940 }
2941 ret = TRUE;
2942 done:
2943 CloseHandle( h1 );
2944 CloseHandle( h2 );
2945 return ret;
2946 }
2947
2948
2949 /**************************************************************************
2950 * CopyFileA (KERNEL32.@)
2951 */
2952 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
2953 {
2954 UNICODE_STRING sourceW, destW;
2955 BOOL ret;
2956
2957 if (!source || !dest)
2958 {
2959 SetLastError(ERROR_INVALID_PARAMETER);
2960 return FALSE;
2961 }
2962
2963 RtlCreateUnicodeStringFromAsciiz(&sourceW, source);
2964 RtlCreateUnicodeStringFromAsciiz(&destW, dest);
2965
2966 ret = CopyFileW(sourceW.Buffer, destW.Buffer, fail_if_exists);
2967
2968 RtlFreeUnicodeString(&sourceW);
2969 RtlFreeUnicodeString(&destW);
2970 return ret;
2971 }
2972
2973
2974 /**************************************************************************
2975 * CopyFileExW (KERNEL32.@)
2976 *
2977 * This implementation ignores most of the extra parameters passed-in into
2978 * the "ex" version of the method and calls the CopyFile method.
2979 * It will have to be fixed eventually.
2980 */
2981 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename, LPCWSTR destFilename,
2982 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2983 LPBOOL cancelFlagPointer, DWORD copyFlags)
2984 {
2985 /*
2986 * Interpret the only flag that CopyFile can interpret.
2987 */
2988 return CopyFileW(sourceFilename, destFilename, (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0);
2989 }
2990
2991 /**************************************************************************
2992 * CopyFileExA (KERNEL32.@)
2993 */
2994 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
2995 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2996 LPBOOL cancelFlagPointer, DWORD copyFlags)
2997 {
2998 UNICODE_STRING sourceW, destW;
2999 BOOL ret;
3000
3001 if (!sourceFilename || !destFilename)
3002 {
3003 SetLastError(ERROR_INVALID_PARAMETER);
3004 return FALSE;
3005 }
3006
3007 RtlCreateUnicodeStringFromAsciiz(&sourceW, sourceFilename);
3008 RtlCreateUnicodeStringFromAsciiz(&destW, destFilename);
3009
3010 ret = CopyFileExW(sourceW.Buffer, destW.Buffer, progressRoutine, appData,
3011 cancelFlagPointer, copyFlags);
3012
3013 RtlFreeUnicodeString(&sourceW);
3014 RtlFreeUnicodeString(&destW);
3015 return ret;
3016 }
3017
3018
3019 /***********************************************************************
3020 * SetFileTime (KERNEL32.@)
3021 */
3022 BOOL WINAPI SetFileTime( HANDLE hFile,
3023 const FILETIME *lpCreationTime,
3024 const FILETIME *lpLastAccessTime,
3025 const FILETIME *lpLastWriteTime )
3026 {
3027 BOOL ret;
3028 SERVER_START_REQ( set_file_time )
3029 {
3030 req->handle = hFile;
3031 if (lpLastAccessTime)
3032 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastAccessTime, (DWORD *)&req->access_time );
3033 else
3034 req->access_time = 0; /* FIXME */
3035 if (lpLastWriteTime)
3036 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastWriteTime, (DWORD *)&req->write_time );
3037 else
3038 req->write_time = 0; /* FIXME */
3039 ret = !wine_server_call_err( req );
3040 }
3041 SERVER_END_REQ;
3042 return ret;
3043 }
3044
3045
3046 /**************************************************************************
3047 * LockFile (KERNEL32.@)
3048 */
3049 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
3050 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
3051 {
3052 BOOL ret;
3053
3054 FIXME("not implemented in server\n");
3055
3056 SERVER_START_REQ( lock_file )
3057 {
3058 req->handle = hFile;
3059 req->offset_low = dwFileOffsetLow;
3060 req->offset_high = dwFileOffsetHigh;
3061 req->count_low = nNumberOfBytesToLockLow;
3062 req->count_high = nNumberOfBytesToLockHigh;
3063 ret = !wine_server_call_err( req );
3064 }
3065 SERVER_END_REQ;
3066 return ret;
3067 }
3068
3069 /**************************************************************************
3070 * LockFileEx [KERNEL32.@]
3071 *
3072 * Locks a byte range within an open file for shared or exclusive access.
3073 *
3074 * RETURNS
3075 * success: TRUE
3076 * failure: FALSE
3077 *
3078 * NOTES
3079 * Per Microsoft docs, the third parameter (reserved) must be set to 0.
3080 */
3081 BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
3082 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
3083 LPOVERLAPPED pOverlapped )
3084 {
3085 FIXME("hFile=%d,flags=%ld,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
3086 hFile, flags, reserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh,
3087 pOverlapped);
3088 if (reserved == 0)
3089 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3090 else
3091 {
3092 ERR("reserved == %ld: Supposed to be 0??\n", reserved);
3093 SetLastError(ERROR_INVALID_PARAMETER);
3094 }
3095
3096 return FALSE;
3097 }
3098
3099
3100 /**************************************************************************
3101 * UnlockFile (KERNEL32.@)
3102 */
3103 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
3104 DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
3105 {
3106 BOOL ret;
3107
3108 FIXME("not implemented in server\n");
3109
3110 SERVER_START_REQ( unlock_file )
3111 {
3112 req->handle = hFile;
3113 req->offset_low = dwFileOffsetLow;
3114 req->offset_high = dwFileOffsetHigh;
3115 req->count_low = nNumberOfBytesToUnlockLow;
3116 req->count_high = nNumberOfBytesToUnlockHigh;
3117 ret = !wine_server_call_err( req );
3118 }
3119 SERVER_END_REQ;
3120 return ret;
3121 }
3122
3123
3124 /**************************************************************************
3125 * UnlockFileEx (KERNEL32.@)
3126 */
3127 BOOL WINAPI UnlockFileEx(
3128 HANDLE hFile,
3129 DWORD dwReserved,
3130 DWORD nNumberOfBytesToUnlockLow,
3131 DWORD nNumberOfBytesToUnlockHigh,
3132 LPOVERLAPPED lpOverlapped
3133 )
3134 {
3135 FIXME("hFile=%d,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
3136 hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh,
3137 lpOverlapped);
3138 if (dwReserved == 0)
3139 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3140 else
3141 {
3142 ERR("reserved == %ld: Supposed to be 0??\n", dwReserved);
3143 SetLastError(ERROR_INVALID_PARAMETER);
3144 }
3145
3146 return FALSE;
3147 }
3148
3149
3150 #if 0
3151
3152 struct DOS_FILE_LOCK {
3153 struct DOS_FILE_LOCK * next;
3154 DWORD base;
3155 DWORD len;
3156 DWORD processId;
3157 FILE_OBJECT * dos_file;
3158 /* char * unix_name;*/
3159 };
3160
3161 typedef struct DOS_FILE_LOCK DOS_FILE_LOCK;
3162
3163 static DOS_FILE_LOCK *locks = NULL;
3164 static void DOS_RemoveFileLocks(FILE_OBJECT *file);
3165
3166
3167 /* Locks need to be mirrored because unix file locking is based
3168 * on the pid. Inside of wine there can be multiple WINE processes
3169 * that share the same unix pid.
3170 * Read's and writes should check these locks also - not sure
3171 * how critical that is at this point (FIXME).
3172 */
3173
3174 static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
3175 {
3176 DOS_FILE_LOCK *curr;
3177 DWORD processId;
3178
3179 processId = GetCurrentProcessId();
3180
3181 /* check if lock overlaps a current lock for the same file */
3182 #if 0
3183 for (curr = locks; curr; curr = curr->next) {
3184 if (strcmp(curr->unix_name, file->unix_name) == 0) {
3185 if ((f->l_start == curr->base) && (f->l_len == curr->len))
3186 return TRUE;/* region is identic */
3187 if ((f->l_start < (curr->base + curr->len)) &&
3188 ((f->l_start + f->l_len) > curr->base)) {
3189 /* region overlaps */
3190 return FALSE;
3191 }
3192 }
3193 }
3194 #endif
3195
3196 curr = HeapAlloc( GetProcessHeap(), 0, sizeof(DOS_FILE_LOCK) );
3197 curr->processId = GetCurrentProcessId();
3198 curr->base = f->l_start;
3199 curr->len = f->l_len;
3200 /* curr->unix_name = HEAP_strdupA( GetProcessHeap(), 0, file->unix_name);*/
3201 curr->next = locks;
3202 curr->dos_file = file;
3203 locks = curr;
3204 return TRUE;
3205 }
3206
3207 static void DOS_RemoveFileLocks(FILE_OBJECT *file)
3208 {
3209 DWORD processId;
3210 DOS_FILE_LOCK **curr;
3211 DOS_FILE_LOCK *rem;
3212
3213 processId = GetCurrentProcessId();
3214 curr = &locks;
3215 while (*curr) {
3216 if ((*curr)->dos_file == file) {
3217 rem = *curr;
3218 *curr = (*curr)->next;
3219 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
3220 HeapFree( GetProcessHeap(), 0, rem );
3221 }
3222 else
3223 curr = &(*curr)->next;
3224 }
3225 }
3226
3227 static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
3228 {
3229 DWORD processId;
3230 DOS_FILE_LOCK **curr;
3231 DOS_FILE_LOCK *rem;
3232
3233 processId = GetCurrentProcessId();
3234 for (curr = &locks; *curr; curr = &(*curr)->next) {
3235 if ((*curr)->processId == processId &&
3236 (*curr)->dos_file == file &&
3237 (*curr)->base == f->l_start &&
3238 (*curr)->len == f->l_len) {
3239 /* this is the same lock */
3240 rem = *curr;
3241 *curr = (*curr)->next;
3242 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
3243 HeapFree( GetProcessHeap(), 0, rem );
3244 return TRUE;
3245 }
3246 }
3247 /* no matching lock found */
3248 return FALSE;
3249 }
3250
3251
3252 /**************************************************************************
3253 * LockFile (KERNEL32.@)
3254 */
3255 BOOL WINAPI LockFile(
3256 HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
3257 DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
3258 {
3259 struct flock f;
3260 FILE_OBJECT *file;
3261
3262 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
3263 hFile, dwFileOffsetLow, dwFileOffsetHigh,
3264 nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh);
3265
3266 if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) {
3267 FIXME("Unimplemented bytes > 32bits\n");
3268 return FALSE;
3269 }
3270
3271 f.l_start = dwFileOffsetLow;
3272 f.l_len = nNumberOfBytesToLockLow;
3273 f.l_whence = SEEK_SET;
3274 f.l_pid = 0;
3275 f.l_type = F_WRLCK;
3276
3277 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
3278
3279 /* shadow locks internally */
3280 if (!DOS_AddLock(file, &f)) {
3281 SetLastError( ERROR_LOCK_VIOLATION );
3282 return FALSE;
3283 }
3284
3285 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
3286 #ifdef USE_UNIX_LOCKS
3287 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
3288 if (errno == EACCES || errno == EAGAIN) {
3289 SetLastError( ERROR_LOCK_VIOLATION );
3290 }
3291 else {
3292 FILE_SetDosError();
3293 }
3294 /* remove our internal copy of the lock */
3295 DOS_RemoveLock(file, &f);
3296 return FALSE;
3297 }
3298 #endif
3299 return TRUE;
3300 }
3301
3302
3303 /**************************************************************************
3304 * UnlockFile (KERNEL32.@)
3305 */
3306 BOOL WINAPI UnlockFile(
3307 HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
3308 DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
3309 {
3310 FILE_OBJECT *file;
3311 struct flock f;
3312
3313 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
3314 hFile, dwFileOffsetLow, dwFileOffsetHigh,
3315 nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);
3316
3317 if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) {
3318 WARN("Unimplemented bytes > 32bits\n");
3319 return FALSE;
3320 }
3321
3322 f.l_start = dwFileOffsetLow;
3323 f.l_len = nNumberOfBytesToUnlockLow;
3324 f.l_whence = SEEK_SET;
3325 f.l_pid = 0;
3326 f.l_type = F_UNLCK;
3327
3328 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
3329
3330 DOS_RemoveLock(file, &f); /* ok if fails - may be another wine */
3331
3332 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
3333 #ifdef USE_UNIX_LOCKS
3334 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
3335 FILE_SetDosError();
3336 return FALSE;
3337 }
3338 #endif
3339 return TRUE;
3340 }
3341 #endif
3342
3343 /**************************************************************************
3344 * GetFileAttributesExW (KERNEL32.@)
3345 */
3346 BOOL WINAPI GetFileAttributesExW(
3347 LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
3348 LPVOID lpFileInformation)
3349 {
3350 DOS_FULL_NAME full_name;
3351 BY_HANDLE_FILE_INFORMATION info;
3352
3353 if (!lpFileName || !lpFileInformation)
3354 {
3355 SetLastError(ERROR_INVALID_PARAMETER);
3356 return FALSE;
3357 }
3358
3359 if (fInfoLevelId == GetFileExInfoStandard) {
3360 LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
3361 (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
3362 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
3363 if (!FILE_Stat( full_name.long_name, &info )) return FALSE;
3364
3365 lpFad->dwFileAttributes = info.dwFileAttributes;
3366 lpFad->ftCreationTime = info.ftCreationTime;
3367 lpFad->ftLastAccessTime = info.ftLastAccessTime;
3368 lpFad->ftLastWriteTime = info.ftLastWriteTime;
3369 lpFad->nFileSizeHigh = info.nFileSizeHigh;
3370 lpFad->nFileSizeLow = info.nFileSizeLow;
3371 }
3372 else {
3373 FIXME("invalid info level %d!\n", fInfoLevelId);
3374 return FALSE;
3375 }
3376
3377 return TRUE;
3378 }
3379
3380
3381 /**************************************************************************
3382 * GetFileAttributesExA (KERNEL32.@)
3383 */
3384 BOOL WINAPI GetFileAttributesExA(
3385 LPCSTR filename, GET_FILEEX_INFO_LEVELS fInfoLevelId,
3386 LPVOID lpFileInformation)
3387 {
3388 UNICODE_STRING filenameW;
3389 BOOL ret = FALSE;
3390
3391 if (!filename || !lpFileInformation)
3392 {
3393 SetLastError(ERROR_INVALID_PARAMETER);
3394 return FALSE;
3395 }
3396
3397 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
3398 {
3399 ret = GetFileAttributesExW(filenameW.Buffer, fInfoLevelId, lpFileInformation);
3400 RtlFreeUnicodeString(&filenameW);
3401 }
3402 else
3403 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3404 return ret;
3405 }
Maarten's multimedia branch