?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Compile the shlwapi dll with -DSTRICT.
[wine/gsoc_dplay.git] / files / file.c
blob7f875f126ac49225065c200c548643940c4653e8
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 (ofs->Reserved1 != filedatetime[0] || ofs->Reserved2 != filedatetime[1] )
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 ofs->Reserved1 = filedatetime[0];
1339 ofs->Reserved2 = filedatetime[1];
1340
1341 success: /* We get here if the open was successful */
1342 TRACE("(%s): OK, return = %x\n", name, handle );
1343 if (win32)
1344 {
1345 hFileRet = (HFILE)handle;
1346 if (mode & OF_EXIST) /* Return the handle, but close it first */
1347 CloseHandle( handle );
1348 }
1349 else
1350 {
1351 hFileRet = Win32HandleToDosFileHandle( handle );
1352 if (hFileRet == HFILE_ERROR16) goto error;
1353 if (mode & OF_EXIST) /* Return the handle, but close it first */
1354 _lclose16( hFileRet );
1355 }
1356 return hFileRet;
1357
1358 not_found: /* We get here if the file does not exist */
1359 WARN("'%s' not found or sharing violation\n", name );
1360 SetLastError( ERROR_FILE_NOT_FOUND );
1361 /* fall through */
1362
1363 error: /* We get here if there was an error opening the file */
1364 ofs->nErrCode = GetLastError();
1365 WARN("(%s): return = HFILE_ERROR error= %d\n",
1366 name,ofs->nErrCode );
1367 return HFILE_ERROR;
1368 }
1369
1370
1371 /***********************************************************************
1372 * OpenFile (KERNEL.74)
1373 * OpenFileEx (KERNEL.360)
1374 */
1375 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
1376 {
1377 return FILE_DoOpenFile( name, ofs, mode, FALSE );
1378 }
1379
1380
1381 /***********************************************************************
1382 * OpenFile (KERNEL32.@)
1383 */
1384 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
1385 {
1386 return FILE_DoOpenFile( name, ofs, mode, TRUE );
1387 }
1388
1389
1390 /***********************************************************************
1391 * FILE_InitProcessDosHandles
1392 *
1393 * Allocates the default DOS handles for a process. Called either by
1394 * Win32HandleToDosFileHandle below or by the DOSVM stuff.
1395 */
1396 static void FILE_InitProcessDosHandles( void )
1397 {
1398 HANDLE cp = GetCurrentProcess();
1399 DuplicateHandle(cp, GetStdHandle(STD_INPUT_HANDLE), cp, &dos_handles[0],
1400 0, TRUE, DUPLICATE_SAME_ACCESS);
1401 DuplicateHandle(cp, GetStdHandle(STD_OUTPUT_HANDLE), cp, &dos_handles[1],
1402 0, TRUE, DUPLICATE_SAME_ACCESS);
1403 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[2],
1404 0, TRUE, DUPLICATE_SAME_ACCESS);
1405 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[3],
1406 0, TRUE, DUPLICATE_SAME_ACCESS);
1407 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[4],
1408 0, TRUE, DUPLICATE_SAME_ACCESS);
1409 }
1410
1411 /***********************************************************************
1412 * Win32HandleToDosFileHandle (KERNEL32.21)
1413 *
1414 * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
1415 * longer valid after this function (even on failure).
1416 *
1417 * Note: this is not exactly right, since on Win95 the Win32 handles
1418 * are on top of DOS handles and we do it the other way
1419 * around. Should be good enough though.
1420 */
1421 HFILE WINAPI Win32HandleToDosFileHandle( HANDLE handle )
1422 {
1423 int i;
1424
1425 if (!handle || (handle == INVALID_HANDLE_VALUE))
1426 return HFILE_ERROR;
1427
1428 for (i = 5; i < DOS_TABLE_SIZE; i++)
1429 if (!dos_handles[i])
1430 {
1431 dos_handles[i] = handle;
1432 TRACE("Got %d for h32 %d\n", i, handle );
1433 return (HFILE)i;
1434 }
1435 CloseHandle( handle );
1436 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1437 return HFILE_ERROR;
1438 }
1439
1440
1441 /***********************************************************************
1442 * DosFileHandleToWin32Handle (KERNEL32.20)
1443 *
1444 * Return the Win32 handle for a DOS handle.
1445 *
1446 * Note: this is not exactly right, since on Win95 the Win32 handles
1447 * are on top of DOS handles and we do it the other way
1448 * around. Should be good enough though.
1449 */
1450 HANDLE WINAPI DosFileHandleToWin32Handle( HFILE handle )
1451 {
1452 HFILE16 hfile = (HFILE16)handle;
1453 if (hfile < 5 && !dos_handles[hfile]) FILE_InitProcessDosHandles();
1454 if ((hfile >= DOS_TABLE_SIZE) || !dos_handles[hfile])
1455 {
1456 SetLastError( ERROR_INVALID_HANDLE );
1457 return INVALID_HANDLE_VALUE;
1458 }
1459 return dos_handles[hfile];
1460 }
1461
1462
1463 /***********************************************************************
1464 * DisposeLZ32Handle (KERNEL32.22)
1465 *
1466 * Note: this is not entirely correct, we should only close the
1467 * 32-bit handle and not the 16-bit one, but we cannot do
1468 * this because of the way our DOS handles are implemented.
1469 * It shouldn't break anything though.
1470 */
1471 void WINAPI DisposeLZ32Handle( HANDLE handle )
1472 {
1473 int i;
1474
1475 if (!handle || (handle == INVALID_HANDLE_VALUE)) return;
1476
1477 for (i = 5; i < DOS_TABLE_SIZE; i++)
1478 if (dos_handles[i] == handle)
1479 {
1480 dos_handles[i] = 0;
1481 CloseHandle( handle );
1482 break;
1483 }
1484 }
1485
1486
1487 /***********************************************************************
1488 * FILE_Dup2
1489 *
1490 * dup2() function for DOS handles.
1491 */
1492 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1493 {
1494 HANDLE new_handle;
1495
1496 if (hFile1 < 5 && !dos_handles[hFile1]) FILE_InitProcessDosHandles();
1497
1498 if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) || !dos_handles[hFile1])
1499 {
1500 SetLastError( ERROR_INVALID_HANDLE );
1501 return HFILE_ERROR16;
1502 }
1503 if (!DuplicateHandle( GetCurrentProcess(), dos_handles[hFile1],
1504 GetCurrentProcess(), &new_handle,
1505 0, FALSE, DUPLICATE_SAME_ACCESS ))
1506 return HFILE_ERROR16;
1507 if (dos_handles[hFile2]) CloseHandle( dos_handles[hFile2] );
1508 dos_handles[hFile2] = new_handle;
1509 return hFile2;
1510 }
1511
1512
1513 /***********************************************************************
1514 * _lclose (KERNEL.81)
1515 */
1516 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1517 {
1518 if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
1519 {
1520 SetLastError( ERROR_INVALID_HANDLE );
1521 return HFILE_ERROR16;
1522 }
1523 TRACE("%d (handle32=%d)\n", hFile, dos_handles[hFile] );
1524 CloseHandle( dos_handles[hFile] );
1525 dos_handles[hFile] = 0;
1526 return 0;
1527 }
1528
1529
1530 /***********************************************************************
1531 * _lclose (KERNEL32.@)
1532 */
1533 HFILE WINAPI _lclose( HFILE hFile )
1534 {
1535 TRACE("handle %d\n", hFile );
1536 return CloseHandle( (HANDLE)hFile ) ? 0 : HFILE_ERROR;
1537 }
1538
1539 /***********************************************************************
1540 * GetOverlappedResult (KERNEL32.@)
1541 *
1542 * Check the result of an Asynchronous data transfer from a file.
1543 *
1544 * RETURNS
1545 * TRUE on success
1546 * FALSE on failure
1547 *
1548 * If successful (and relevant) lpTransferred will hold the number of
1549 * bytes transferred during the async operation.
1550 *
1551 * BUGS
1552 *
1553 * Currently only works for WaitCommEvent, ReadFile, WriteFile
1554 * with communications ports.
1555 *
1556 */
1557 BOOL WINAPI GetOverlappedResult(
1558 HANDLE hFile, /* [in] handle of file to check on */
1559 LPOVERLAPPED lpOverlapped, /* [in/out] pointer to overlapped */
1560 LPDWORD lpTransferred, /* [in/out] number of bytes transferred */
1561 BOOL bWait /* [in] wait for the transfer to complete ? */
1562 ) {
1563 DWORD r;
1564
1565 TRACE("(%d %p %p %x)\n", hFile, lpOverlapped, lpTransferred, bWait);
1566
1567 if(lpOverlapped==NULL)
1568 {
1569 ERR("lpOverlapped was null\n");
1570 return FALSE;
1571 }
1572 if(!lpOverlapped->hEvent)
1573 {
1574 ERR("lpOverlapped->hEvent was null\n");
1575 return FALSE;
1576 }
1577
1578 if ( bWait )
1579 {
1580 do {
1581 TRACE("waiting on %p\n",lpOverlapped);
1582 r = WaitForSingleObjectEx(lpOverlapped->hEvent, INFINITE, TRUE);
1583 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1584 } while (r==STATUS_USER_APC);
1585 }
1586 else if ( lpOverlapped->Internal == STATUS_PENDING )
1587 {
1588 /* Wait in order to give APCs a chance to run. */
1589 /* This is cheating, so we must set the event again in case of success -
1590 it may be a non-manual reset event. */
1591 do {
1592 TRACE("waiting on %p\n",lpOverlapped);
1593 r = WaitForSingleObjectEx(lpOverlapped->hEvent, 0, TRUE);
1594 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1595 } while (r==STATUS_USER_APC);
1596 if ( r == WAIT_OBJECT_0 )
1597 NtSetEvent ( lpOverlapped->hEvent, NULL );
1598 }
1599
1600 if(lpTransferred)
1601 *lpTransferred = lpOverlapped->InternalHigh;
1602
1603 switch ( lpOverlapped->Internal )
1604 {
1605 case STATUS_SUCCESS:
1606 return TRUE;
1607 case STATUS_PENDING:
1608 SetLastError ( ERROR_IO_INCOMPLETE );
1609 if ( bWait ) ERR ("PENDING status after waiting!\n");
1610 return FALSE;
1611 default:
1612 SetLastError ( RtlNtStatusToDosError ( lpOverlapped->Internal ) );
1613 return FALSE;
1614 }
1615 }
1616
1617 /***********************************************************************
1618 * CancelIo (KERNEL32.@)
1619 */
1620 BOOL WINAPI CancelIo(HANDLE handle)
1621 {
1622 async_private *ovp,*t;
1623
1624 TRACE("handle = %x\n",handle);
1625
1626 for (ovp = NtCurrentTeb()->pending_list; ovp; ovp = t)
1627 {
1628 t = ovp->next;
1629 if ( ovp->handle == handle )
1630 cancel_async ( ovp );
1631 }
1632 WaitForMultipleObjectsEx(0,NULL,FALSE,1,TRUE);
1633 return TRUE;
1634 }
1635
1636 /***********************************************************************
1637 * FILE_AsyncReadService (INTERNAL)
1638 *
1639 * This function is called while the client is waiting on the
1640 * server, so we can't make any server calls here.
1641 */
1642 static void FILE_AsyncReadService(async_private *ovp)
1643 {
1644 async_fileio *fileio = (async_fileio*) ovp;
1645 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1646 int result, r;
1647 int already = lpOverlapped->InternalHigh;
1648
1649 TRACE("%p %p\n", lpOverlapped, fileio->buffer );
1650
1651 /* check to see if the data is ready (non-blocking) */
1652
1653 if ( fileio->fd_type == FD_TYPE_SOCKET )
1654 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1655 else
1656 {
1657 result = pread (ovp->fd, &fileio->buffer[already], fileio->count - already,
1658 OVERLAPPED_OFFSET (lpOverlapped) + already);
1659 if ((result < 0) && (errno == ESPIPE))
1660 result = read (ovp->fd, &fileio->buffer[already], fileio->count - already);
1661 }
1662
1663 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1664 {
1665 TRACE("Deferred read %d\n",errno);
1666 r = STATUS_PENDING;
1667 goto async_end;
1668 }
1669
1670 /* check to see if the transfer is complete */
1671 if(result<0)
1672 {
1673 r = FILE_GetNtStatus ();
1674 goto async_end;
1675 }
1676
1677 lpOverlapped->InternalHigh += result;
1678 TRACE("read %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1679
1680 if(lpOverlapped->InternalHigh >= fileio->count || fileio->fd_type == FD_TYPE_SOCKET )
1681 r = STATUS_SUCCESS;
1682 else
1683 r = STATUS_PENDING;
1684
1685 async_end:
1686 lpOverlapped->Internal = r;
1687 }
1688
1689 /***********************************************************************
1690 * FILE_ReadFileEx (INTERNAL)
1691 */
1692 static BOOL FILE_ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1693 LPOVERLAPPED overlapped,
1694 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1695 HANDLE hEvent)
1696 {
1697 async_fileio *ovp;
1698 int fd;
1699 int flags;
1700 enum fd_type type;
1701
1702 TRACE("file %d to buf %p num %ld %p func %p\n",
1703 hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine);
1704
1705 /* check that there is an overlapped struct */
1706 if (overlapped==NULL)
1707 {
1708 SetLastError(ERROR_INVALID_PARAMETER);
1709 return FALSE;
1710 }
1711
1712 fd = FILE_GetUnixHandleType ( hFile, GENERIC_READ, &type, &flags);
1713 if ( fd < 0 )
1714 {
1715 WARN ( "Couldn't get FD\n" );
1716 return FALSE;
1717 }
1718
1719 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1720 if(!ovp)
1721 {
1722 TRACE("HeapAlloc Failed\n");
1723 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1724 goto error;
1725 }
1726
1727 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1728 ovp->async.handle = hFile;
1729 ovp->async.fd = fd;
1730 ovp->async.type = ASYNC_TYPE_READ;
1731 ovp->async.func = FILE_AsyncReadService;
1732 ovp->async.event = hEvent;
1733 ovp->lpOverlapped = overlapped;
1734 ovp->count = bytesToRead;
1735 ovp->completion_func = lpCompletionRoutine;
1736 ovp->buffer = buffer;
1737 ovp->fd_type = type;
1738
1739 return !register_new_async (&ovp->async);
1740
1741 error:
1742 close (fd);
1743 return FALSE;
1744
1745 }
1746
1747 /***********************************************************************
1748 * ReadFileEx (KERNEL32.@)
1749 */
1750 BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1751 LPOVERLAPPED overlapped,
1752 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1753 {
1754 overlapped->InternalHigh = 0;
1755 return FILE_ReadFileEx(hFile,buffer,bytesToRead,overlapped,lpCompletionRoutine, INVALID_HANDLE_VALUE);
1756 }
1757
1758 static BOOL FILE_TimeoutRead(HANDLE hFile, LPVOID buffer, DWORD bytesToRead, LPDWORD bytesRead)
1759 {
1760 OVERLAPPED ov;
1761 BOOL r = FALSE;
1762
1763 TRACE("%d %p %ld %p\n", hFile, buffer, bytesToRead, bytesRead );
1764
1765 ZeroMemory(&ov, sizeof (OVERLAPPED));
1766 if(STATUS_SUCCESS==NtCreateEvent(&ov.hEvent, SYNCHRONIZE, NULL, 0, 0))
1767 {
1768 if(FILE_ReadFileEx(hFile, buffer, bytesToRead, &ov, NULL, ov.hEvent))
1769 {
1770 r = GetOverlappedResult(hFile, &ov, bytesRead, TRUE);
1771 }
1772 }
1773 CloseHandle(ov.hEvent);
1774 return r;
1775 }
1776
1777 /***********************************************************************
1778 * ReadFile (KERNEL32.@)
1779 */
1780 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1781 LPDWORD bytesRead, LPOVERLAPPED overlapped )
1782 {
1783 int unix_handle, result, flags;
1784 enum fd_type type;
1785
1786 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToRead,
1787 bytesRead, overlapped );
1788
1789 if (bytesRead) *bytesRead = 0; /* Do this before anything else */
1790 if (!bytesToRead) return TRUE;
1791
1792 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_READ, &type, &flags );
1793
1794 if (flags & FD_FLAG_OVERLAPPED)
1795 {
1796 if (unix_handle == -1) return FALSE;
1797 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
1798 {
1799 TRACE("Overlapped not specified or invalid event flag\n");
1800 close(unix_handle);
1801 SetLastError(ERROR_INVALID_PARAMETER);
1802 return FALSE;
1803 }
1804
1805 close(unix_handle);
1806 overlapped->InternalHigh = 0;
1807
1808 if(!FILE_ReadFileEx(hFile, buffer, bytesToRead, overlapped, NULL, overlapped->hEvent))
1809 return FALSE;
1810
1811 if ( !GetOverlappedResult (hFile, overlapped, bytesRead, FALSE) )
1812 {
1813 if ( GetLastError() == ERROR_IO_INCOMPLETE )
1814 SetLastError ( ERROR_IO_PENDING );
1815 return FALSE;
1816 }
1817
1818 return TRUE;
1819 }
1820 if (flags & FD_FLAG_TIMEOUT)
1821 {
1822 close(unix_handle);
1823 return FILE_TimeoutRead(hFile, buffer, bytesToRead, bytesRead);
1824 }
1825 switch(type)
1826 {
1827 case FD_TYPE_SMB:
1828 return SMB_ReadFile(hFile, buffer, bytesToRead, bytesRead, NULL);
1829
1830 case FD_TYPE_CONSOLE:
1831 return FILE_ReadConsole(hFile, buffer, bytesToRead, bytesRead, NULL);
1832
1833 case FD_TYPE_DEFAULT:
1834 /* normal unix files */
1835 if (unix_handle == -1) return FALSE;
1836 if (overlapped)
1837 {
1838 DWORD highOffset = overlapped->OffsetHigh;
1839 if ( (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, overlapped->Offset,
1840 &highOffset, FILE_BEGIN)) &&
1841 (GetLastError() != NO_ERROR) )
1842 {
1843 close(unix_handle);
1844 return FALSE;
1845 }
1846 }
1847 break;
1848
1849 default:
1850 if (unix_handle == -1)
1851 return FALSE;
1852 }
1853
1854 if(overlapped)
1855 {
1856 off_t offset = OVERLAPPED_OFFSET(overlapped);
1857 if(lseek(unix_handle, offset, SEEK_SET) == -1)
1858 {
1859 close(unix_handle);
1860 SetLastError(ERROR_INVALID_PARAMETER);
1861 return FALSE;
1862 }
1863 }
1864
1865 /* code for synchronous reads */
1866 while ((result = read( unix_handle, buffer, bytesToRead )) == -1)
1867 {
1868 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1869 if ((errno == EFAULT) && !IsBadWritePtr( buffer, bytesToRead )) continue;
1870 FILE_SetDosError();
1871 break;
1872 }
1873 close( unix_handle );
1874 if (result == -1) return FALSE;
1875 if (bytesRead) *bytesRead = result;
1876 return TRUE;
1877 }
1878
1879
1880 /***********************************************************************
1881 * FILE_AsyncWriteService (INTERNAL)
1882 *
1883 * This function is called while the client is waiting on the
1884 * server, so we can't make any server calls here.
1885 */
1886 static void FILE_AsyncWriteService(struct async_private *ovp)
1887 {
1888 async_fileio *fileio = (async_fileio *) ovp;
1889 LPOVERLAPPED lpOverlapped = fileio->lpOverlapped;
1890 int result, r;
1891 int already = lpOverlapped->InternalHigh;
1892
1893 TRACE("(%p %p)\n",lpOverlapped,fileio->buffer);
1894
1895 /* write some data (non-blocking) */
1896
1897 if ( fileio->fd_type == FD_TYPE_SOCKET )
1898 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1899 else
1900 {
1901 result = pwrite(ovp->fd, &fileio->buffer[already], fileio->count - already,
1902 OVERLAPPED_OFFSET (lpOverlapped) + already);
1903 if ((result < 0) && (errno == ESPIPE))
1904 result = write(ovp->fd, &fileio->buffer[already], fileio->count - already);
1905 }
1906
1907 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1908 {
1909 r = STATUS_PENDING;
1910 goto async_end;
1911 }
1912
1913 /* check to see if the transfer is complete */
1914 if(result<0)
1915 {
1916 r = FILE_GetNtStatus ();
1917 goto async_end;
1918 }
1919
1920 lpOverlapped->InternalHigh += result;
1921
1922 TRACE("wrote %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count);
1923
1924 if(lpOverlapped->InternalHigh < fileio->count)
1925 r = STATUS_PENDING;
1926 else
1927 r = STATUS_SUCCESS;
1928
1929 async_end:
1930 lpOverlapped->Internal = r;
1931 }
1932
1933 /***********************************************************************
1934 * FILE_WriteFileEx
1935 */
1936 static BOOL FILE_WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1937 LPOVERLAPPED overlapped,
1938 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1939 HANDLE hEvent)
1940 {
1941 async_fileio *ovp;
1942 int fd;
1943 int flags;
1944 enum fd_type type;
1945
1946 TRACE("file %d to buf %p num %ld %p func %p handle %d\n",
1947 hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, hEvent);
1948
1949 if (overlapped == NULL)
1950 {
1951 SetLastError(ERROR_INVALID_PARAMETER);
1952 return FALSE;
1953 }
1954
1955 fd = FILE_GetUnixHandleType ( hFile, GENERIC_WRITE, &type, &flags );
1956 if ( fd < 0 )
1957 {
1958 TRACE( "Couldn't get FD\n" );
1959 return FALSE;
1960 }
1961
1962 ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio));
1963 if(!ovp)
1964 {
1965 TRACE("HeapAlloc Failed\n");
1966 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1967 goto error;
1968 }
1969
1970 ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops );
1971 ovp->async.handle = hFile;
1972 ovp->async.fd = fd;
1973 ovp->async.type = ASYNC_TYPE_WRITE;
1974 ovp->async.func = FILE_AsyncWriteService;
1975 ovp->lpOverlapped = overlapped;
1976 ovp->async.event = hEvent;
1977 ovp->buffer = (LPVOID) buffer;
1978 ovp->count = bytesToWrite;
1979 ovp->completion_func = lpCompletionRoutine;
1980 ovp->fd_type = type;
1981
1982 return !register_new_async (&ovp->async);
1983
1984 error:
1985 close (fd);
1986 return FALSE;
1987 }
1988
1989 /***********************************************************************
1990 * WriteFileEx (KERNEL32.@)
1991 */
1992 BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1993 LPOVERLAPPED overlapped,
1994 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1995 {
1996 overlapped->InternalHigh = 0;
1997
1998 return FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, INVALID_HANDLE_VALUE);
1999 }
2000
2001 /***********************************************************************
2002 * WriteFile (KERNEL32.@)
2003 */
2004 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
2005 LPDWORD bytesWritten, LPOVERLAPPED overlapped )
2006 {
2007 int unix_handle, result, flags;
2008 enum fd_type type;
2009
2010 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToWrite,
2011 bytesWritten, overlapped );
2012
2013 if (bytesWritten) *bytesWritten = 0; /* Do this before anything else */
2014 if (!bytesToWrite) return TRUE;
2015
2016 unix_handle = FILE_GetUnixHandleType( hFile, GENERIC_WRITE, &type, &flags );
2017
2018 if (flags & FD_FLAG_OVERLAPPED)
2019 {
2020 if (unix_handle == -1) return FALSE;
2021 if ( (overlapped==NULL) || NtResetEvent( overlapped->hEvent, NULL ) )
2022 {
2023 TRACE("Overlapped not specified or invalid event flag\n");
2024 close(unix_handle);
2025 SetLastError(ERROR_INVALID_PARAMETER);
2026 return FALSE;
2027 }
2028
2029 close(unix_handle);
2030 overlapped->InternalHigh = 0;
2031
2032 if(!FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, NULL, overlapped->hEvent))
2033 return FALSE;
2034
2035 if ( !GetOverlappedResult (hFile, overlapped, bytesWritten, FALSE) )
2036 {
2037 if ( GetLastError() == ERROR_IO_INCOMPLETE )
2038 SetLastError ( ERROR_IO_PENDING );
2039 return FALSE;
2040 }
2041
2042 return TRUE;
2043 }
2044
2045 switch(type)
2046 {
2047 case FD_TYPE_CONSOLE:
2048 TRACE("%d %s %ld %p %p\n", hFile, debugstr_an(buffer, bytesToWrite), bytesToWrite,
2049 bytesWritten, overlapped );
2050 return FILE_WriteConsole(hFile, buffer, bytesToWrite, bytesWritten, NULL);
2051
2052 case FD_TYPE_DEFAULT:
2053 if (unix_handle == -1) return FALSE;
2054
2055 if(overlapped)
2056 {
2057 DWORD highOffset = overlapped->OffsetHigh;
2058 if ( (INVALID_SET_FILE_POINTER == SetFilePointer(hFile, overlapped->Offset,
2059 &highOffset, FILE_BEGIN)) &&
2060 (GetLastError() != NO_ERROR) )
2061 {
2062 close(unix_handle);
2063 return FALSE;
2064 }
2065 }
2066 break;
2067
2068 default:
2069 if (unix_handle == -1)
2070 return FALSE;
2071 if (overlapped)
2072 {
2073 close(unix_handle);
2074 SetLastError(ERROR_INVALID_PARAMETER);
2075 return FALSE;
2076 }
2077 break;
2078 }
2079
2080 if(overlapped)
2081 {
2082 off_t offset = OVERLAPPED_OFFSET(overlapped);
2083 if(lseek(unix_handle, offset, SEEK_SET) == -1)
2084 {
2085 close(unix_handle);
2086 SetLastError(ERROR_INVALID_PARAMETER);
2087 return FALSE;
2088 }
2089 }
2090
2091 /* synchronous file write */
2092 while ((result = write( unix_handle, buffer, bytesToWrite )) == -1)
2093 {
2094 if ((errno == EAGAIN) || (errno == EINTR)) continue;
2095 if ((errno == EFAULT) && !IsBadReadPtr( buffer, bytesToWrite )) continue;
2096 if (errno == ENOSPC)
2097 SetLastError( ERROR_DISK_FULL );
2098 else
2099 FILE_SetDosError();
2100 break;
2101 }
2102 close( unix_handle );
2103 if (result == -1) return FALSE;
2104 if (bytesWritten) *bytesWritten = result;
2105 return TRUE;
2106 }
2107
2108
2109 /***********************************************************************
2110 * _hread (KERNEL.349)
2111 */
2112 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
2113 {
2114 LONG maxlen;
2115
2116 TRACE("%d %08lx %ld\n",
2117 hFile, (DWORD)buffer, count );
2118
2119 /* Some programs pass a count larger than the allocated buffer */
2120 maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
2121 if (count > maxlen) count = maxlen;
2122 return _lread((HFILE)DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
2123 }
2124
2125
2126 /***********************************************************************
2127 * _lread (KERNEL.82)
2128 */
2129 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
2130 {
2131 return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
2132 }
2133
2134
2135 /***********************************************************************
2136 * _lread (KERNEL32.@)
2137 */
2138 UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
2139 {
2140 DWORD result;
2141 if (!ReadFile( (HANDLE)handle, buffer, count, &result, NULL )) return -1;
2142 return result;
2143 }
2144
2145
2146 /***********************************************************************
2147 * _lread16 (KERNEL.82)
2148 */
2149 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
2150 {
2151 return (UINT16)_lread((HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
2152 }
2153
2154
2155 /***********************************************************************
2156 * _lcreat (KERNEL.83)
2157 */
2158 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
2159 {
2160 return Win32HandleToDosFileHandle( (HANDLE)_lcreat( path, attr ) );
2161 }
2162
2163
2164 /***********************************************************************
2165 * _lcreat (KERNEL32.@)
2166 */
2167 HFILE WINAPI _lcreat( LPCSTR path, INT attr )
2168 {
2169 /* Mask off all flags not explicitly allowed by the doc */
2170 attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
2171 TRACE("%s %02x\n", path, attr );
2172 return (HFILE)CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
2173 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2174 CREATE_ALWAYS, attr, 0 );
2175 }
2176
2177
2178 /***********************************************************************
2179 * SetFilePointer (KERNEL32.@)
2180 */
2181 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
2182 DWORD method )
2183 {
2184 DWORD ret = INVALID_SET_FILE_POINTER;
2185
2186 TRACE("handle %d offset %ld high %ld origin %ld\n",
2187 hFile, distance, highword?*highword:0, method );
2188
2189 SERVER_START_REQ( set_file_pointer )
2190 {
2191 req->handle = hFile;
2192 req->low = distance;
2193 req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
2194 /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
2195 req->whence = method;
2196 SetLastError( 0 );
2197 if (!wine_server_call_err( req ))
2198 {
2199 ret = reply->new_low;
2200 if (highword) *highword = reply->new_high;
2201 }
2202 }
2203 SERVER_END_REQ;
2204 return ret;
2205 }
2206
2207
2208 /***********************************************************************
2209 * _llseek (KERNEL.84)
2210 *
2211 * FIXME:
2212 * Seeking before the start of the file should be allowed for _llseek16,
2213 * but cause subsequent I/O operations to fail (cf. interrupt list)
2214 *
2215 */
2216 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
2217 {
2218 return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
2219 }
2220
2221
2222 /***********************************************************************
2223 * _llseek (KERNEL32.@)
2224 */
2225 LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
2226 {
2227 return SetFilePointer( (HANDLE)hFile, lOffset, NULL, nOrigin );
2228 }
2229
2230
2231 /***********************************************************************
2232 * _lopen (KERNEL.85)
2233 */
2234 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
2235 {
2236 return Win32HandleToDosFileHandle( (HANDLE)_lopen( path, mode ) );
2237 }
2238
2239
2240 /***********************************************************************
2241 * _lopen (KERNEL32.@)
2242 */
2243 HFILE WINAPI _lopen( LPCSTR path, INT mode )
2244 {
2245 DWORD access, sharing;
2246
2247 TRACE("('%s',%04x)\n", path, mode );
2248 FILE_ConvertOFMode( mode, &access, &sharing );
2249 return (HFILE)CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, 0 );
2250 }
2251
2252
2253 /***********************************************************************
2254 * _lwrite (KERNEL.86)
2255 */
2256 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
2257 {
2258 return (UINT16)_hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
2259 }
2260
2261 /***********************************************************************
2262 * _lwrite (KERNEL32.@)
2263 */
2264 UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
2265 {
2266 return (UINT)_hwrite( hFile, buffer, (LONG)count );
2267 }
2268
2269
2270 /***********************************************************************
2271 * _hread16 (KERNEL.349)
2272 */
2273 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
2274 {
2275 return _lread( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
2276 }
2277
2278
2279 /***********************************************************************
2280 * _hread (KERNEL32.@)
2281 */
2282 LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
2283 {
2284 return _lread( hFile, buffer, count );
2285 }
2286
2287
2288 /***********************************************************************
2289 * _hwrite (KERNEL.350)
2290 */
2291 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
2292 {
2293 return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
2294 }
2295
2296
2297 /***********************************************************************
2298 * _hwrite (KERNEL32.@)
2299 *
2300 * experimentation yields that _lwrite:
2301 * o truncates the file at the current position with
2302 * a 0 len write
2303 * o returns 0 on a 0 length write
2304 * o works with console handles
2305 *
2306 */
2307 LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
2308 {
2309 DWORD result;
2310
2311 TRACE("%d %p %ld\n", handle, buffer, count );
2312
2313 if (!count)
2314 {
2315 /* Expand or truncate at current position */
2316 if (!SetEndOfFile( (HANDLE)handle )) return HFILE_ERROR;
2317 return 0;
2318 }
2319 if (!WriteFile( (HANDLE)handle, buffer, count, &result, NULL ))
2320 return HFILE_ERROR;
2321 return result;
2322 }
2323
2324
2325 /***********************************************************************
2326 * SetHandleCount (KERNEL.199)
2327 */
2328 UINT16 WINAPI SetHandleCount16( UINT16 count )
2329 {
2330 return SetHandleCount( count );
2331 }
2332
2333
2334 /*************************************************************************
2335 * SetHandleCount (KERNEL32.@)
2336 */
2337 UINT WINAPI SetHandleCount( UINT count )
2338 {
2339 return min( 256, count );
2340 }
2341
2342
2343 /***********************************************************************
2344 * FlushFileBuffers (KERNEL32.@)
2345 */
2346 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
2347 {
2348 BOOL ret;
2349 SERVER_START_REQ( flush_file )
2350 {
2351 req->handle = hFile;
2352 ret = !wine_server_call_err( req );
2353 }
2354 SERVER_END_REQ;
2355 return ret;
2356 }
2357
2358
2359 /**************************************************************************
2360 * SetEndOfFile (KERNEL32.@)
2361 */
2362 BOOL WINAPI SetEndOfFile( HANDLE hFile )
2363 {
2364 BOOL ret;
2365 SERVER_START_REQ( truncate_file )
2366 {
2367 req->handle = hFile;
2368 ret = !wine_server_call_err( req );
2369 }
2370 SERVER_END_REQ;
2371 return ret;
2372 }
2373
2374
2375 /***********************************************************************
2376 * DeleteFile (KERNEL.146)
2377 */
2378 BOOL16 WINAPI DeleteFile16( LPCSTR path )
2379 {
2380 return DeleteFileA( path );
2381 }
2382
2383
2384 /***********************************************************************
2385 * DeleteFileW (KERNEL32.@)
2386 */
2387 BOOL WINAPI DeleteFileW( LPCWSTR path )
2388 {
2389 DOS_FULL_NAME full_name;
2390 HANDLE hFile;
2391
2392 if (!path)
2393 {
2394 SetLastError(ERROR_INVALID_PARAMETER);
2395 return FALSE;
2396 }
2397 TRACE("%s\n", debugstr_w(path) );
2398
2399 if (!*path)
2400 {
2401 ERR("Empty path passed\n");
2402 return FALSE;
2403 }
2404 if (DOSFS_GetDevice( path ))
2405 {
2406 WARN("cannot remove DOS device %s!\n", debugstr_w(path));
2407 SetLastError( ERROR_FILE_NOT_FOUND );
2408 return FALSE;
2409 }
2410
2411 if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
2412
2413 /* check if we are allowed to delete the source */
2414 hFile = FILE_CreateFile( full_name.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2415 NULL, OPEN_EXISTING, 0, 0, TRUE,
2416 GetDriveTypeW( full_name.short_name ) );
2417 if (!hFile) return FALSE;
2418
2419 if (unlink( full_name.long_name ) == -1)
2420 {
2421 FILE_SetDosError();
2422 CloseHandle(hFile);
2423 return FALSE;
2424 }
2425 CloseHandle(hFile);
2426 return TRUE;
2427 }
2428
2429
2430 /***********************************************************************
2431 * DeleteFileA (KERNEL32.@)
2432 */
2433 BOOL WINAPI DeleteFileA( LPCSTR path )
2434 {
2435 UNICODE_STRING pathW;
2436 BOOL ret = FALSE;
2437
2438 if (!path)
2439 {
2440 SetLastError(ERROR_INVALID_PARAMETER);
2441 return FALSE;
2442 }
2443
2444 if (RtlCreateUnicodeStringFromAsciiz(&pathW, path))
2445 {
2446 ret = DeleteFileW(pathW.Buffer);
2447 RtlFreeUnicodeString(&pathW);
2448 }
2449 else
2450 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2451 return ret;
2452 }
2453
2454
2455 /***********************************************************************
2456 * GetFileType (KERNEL32.@)
2457 */
2458 DWORD WINAPI GetFileType( HANDLE hFile )
2459 {
2460 DWORD ret = FILE_TYPE_UNKNOWN;
2461 SERVER_START_REQ( get_file_info )
2462 {
2463 req->handle = hFile;
2464 if (!wine_server_call_err( req )) ret = reply->type;
2465 }
2466 SERVER_END_REQ;
2467 return ret;
2468 }
2469
2470
2471 /* check if a file name is for an executable file (.exe or .com) */
2472 inline static BOOL is_executable( const char *name )
2473 {
2474 int len = strlen(name);
2475
2476 if (len < 4) return FALSE;
2477 return (!strcasecmp( name + len - 4, ".exe" ) ||
2478 !strcasecmp( name + len - 4, ".com" ));
2479 }
2480
2481
2482 /***********************************************************************
2483 * FILE_AddBootRenameEntry
2484 *
2485 * Adds an entry to the registry that is loaded when windows boots and
2486 * checks if there are some files to be removed or renamed/moved.
2487 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
2488 * non-NULL then the file is moved, otherwise it is deleted. The
2489 * entry of the registrykey is always appended with two zero
2490 * terminated strings. If <fn2> is NULL then the second entry is
2491 * simply a single 0-byte. Otherwise the second filename goes
2492 * there. The entries are prepended with \??\ before the path and the
2493 * second filename gets also a '!' as the first character if
2494 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
2495 * 0-byte follows to indicate the end of the strings.
2496 * i.e.:
2497 * \??\D:\test\file1[0]
2498 * !\??\D:\test\file1_renamed[0]
2499 * \??\D:\Test|delete[0]
2500 * [0] <- file is to be deleted, second string empty
2501 * \??\D:\test\file2[0]
2502 * !\??\D:\test\file2_renamed[0]
2503 * [0] <- indicates end of strings
2504 *
2505 * or:
2506 * \??\D:\test\file1[0]
2507 * !\??\D:\test\file1_renamed[0]
2508 * \??\D:\Test|delete[0]
2509 * [0] <- file is to be deleted, second string empty
2510 * [0] <- indicates end of strings
2511 *
2512 */
2513 static BOOL FILE_AddBootRenameEntry( LPCWSTR fn1, LPCWSTR fn2, DWORD flags )
2514 {
2515 static const WCHAR PreString[] = {'\\','?','?','\\',0};
2516 static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
2517 'F','i','l','e','R','e','n','a','m','e',
2518 'O','p','e','r','a','t','i','o','n','s',0};
2519 static const WCHAR SessionW[] = {'M','a','c','h','i','n','e','\\',
2520 'S','y','s','t','e','m','\\',
2521 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
2522 'C','o','n','t','r','o','l','\\',
2523 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
2524 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
2525
2526 OBJECT_ATTRIBUTES attr;
2527 UNICODE_STRING nameW;
2528 KEY_VALUE_PARTIAL_INFORMATION *info;
2529 BOOL rc = FALSE;
2530 HKEY Reboot = 0;
2531 DWORD len0, len1, len2;
2532 DWORD DataSize = 0;
2533 BYTE *Buffer = NULL;
2534 WCHAR *p;
2535
2536 attr.Length = sizeof(attr);
2537 attr.RootDirectory = 0;
2538 attr.ObjectName = &nameW;
2539 attr.Attributes = 0;
2540 attr.SecurityDescriptor = NULL;
2541 attr.SecurityQualityOfService = NULL;
2542 RtlInitUnicodeString( &nameW, SessionW );
2543
2544 if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
2545 {
2546 WARN("Error creating key for reboot managment [%s]\n",
2547 "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
2548 return FALSE;
2549 }
2550
2551 len0 = strlenW(PreString);
2552 len1 = strlenW(fn1) + len0 + 1;
2553 if (fn2)
2554 {
2555 len2 = strlenW(fn2) + len0 + 1;
2556 if (flags & MOVEFILE_REPLACE_EXISTING) len2++; /* Plus 1 because of the leading '!' */
2557 }
2558 else len2 = 1; /* minimum is the 0 characters for the empty second string */
2559
2560 /* convert characters to bytes */
2561 len0 *= sizeof(WCHAR);
2562 len1 *= sizeof(WCHAR);
2563 len2 *= sizeof(WCHAR);
2564
2565 RtlInitUnicodeString( &nameW, ValueName );
2566
2567 /* First we check if the key exists and if so how many bytes it already contains. */
2568 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
2569 NULL, 0, &DataSize ) == STATUS_BUFFER_OVERFLOW)
2570 {
2571 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
2572 goto Quit;
2573 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
2574 Buffer, DataSize, &DataSize )) goto Quit;
2575 info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
2576 if (info->Type != REG_MULTI_SZ) goto Quit;
2577 if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
2578 }
2579 else
2580 {
2581 DataSize = info_size;
2582 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
2583 goto Quit;
2584 }
2585
2586 p = (WCHAR *)(Buffer + DataSize);
2587 strcpyW( p, PreString );
2588 strcatW( p, fn1 );
2589 DataSize += len1;
2590 if (fn2)
2591 {
2592 p = (WCHAR *)(Buffer + DataSize);
2593 if (flags & MOVEFILE_REPLACE_EXISTING)
2594 *p++ = '!';
2595 strcpyW( p, PreString );
2596 strcatW( p, fn2 );
2597 DataSize += len2;
2598 }
2599 else
2600 {
2601 p = (WCHAR *)(Buffer + DataSize);
2602 *p = 0;
2603 DataSize += sizeof(WCHAR);
2604 }
2605
2606 /* add final null */
2607 p = (WCHAR *)(Buffer + DataSize);
2608 *p = 0;
2609 DataSize += sizeof(WCHAR);
2610
2611 rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
2612
2613 Quit:
2614 if (Reboot) NtClose(Reboot);
2615 if (Buffer) HeapFree( GetProcessHeap(), 0, Buffer );
2616 return(rc);
2617 }
2618
2619
2620 /**************************************************************************
2621 * MoveFileExW (KERNEL32.@)
2622 */
2623 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
2624 {
2625 DOS_FULL_NAME full_name1, full_name2;
2626 HANDLE hFile;
2627 DWORD attr = INVALID_FILE_ATTRIBUTES;
2628
2629 TRACE("(%s,%s,%04lx)\n", debugstr_w(fn1), debugstr_w(fn2), flag);
2630
2631 /* FIXME: <Gerhard W. Gruber>sparhawk@gmx.at
2632 In case of W9x and lesser this function should return 120 (ERROR_CALL_NOT_IMPLEMENTED)
2633 to be really compatible. Most programs wont have any problems though. In case
2634 you encounter one, this is what you should return here. I don't know what's up
2635 with NT 3.5. Is this function available there or not?
2636 Does anybody really care about 3.5? :)
2637 */
2638
2639 /* Filename1 has to be always set to a valid path. Filename2 may be NULL
2640 if the source file has to be deleted.
2641 */
2642 if (!fn1) {
2643 SetLastError(ERROR_INVALID_PARAMETER);
2644 return FALSE;
2645 }
2646
2647 /* This function has to be run through in order to process the name properly.
2648 If the BOOTDELAY flag is set, the file doesn't need to exist though. At least
2649 that is the behaviour on NT 4.0. The operation accepts the filenames as
2650 they are given but it can't reply with a reasonable returncode. Success
2651 means in that case success for entering the values into the registry.
2652 */
2653 if(!DOSFS_GetFullName( fn1, TRUE, &full_name1 ))
2654 {
2655 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2656 return FALSE;
2657 }
2658
2659 if (fn2) /* !fn2 means delete fn1 */
2660 {
2661 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
2662 {
2663 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2664 {
2665 /* target exists, check if we may overwrite */
2666 if (!(flag & MOVEFILE_REPLACE_EXISTING))
2667 {
2668 SetLastError( ERROR_FILE_EXISTS );
2669 return FALSE;
2670 }
2671 }
2672 }
2673 else
2674 {
2675 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 ))
2676 {
2677 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
2678 return FALSE;
2679 }
2680 }
2681
2682 /* Source name and target path are valid */
2683
2684 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2685 {
2686 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2687 Perhaps we should queue these command and execute it
2688 when exiting... What about using on_exit(2)
2689 */
2690 FIXME("Please move existing file %s to file %s when Wine has finished\n",
2691 debugstr_w(fn1), debugstr_w(fn2));
2692 return FILE_AddBootRenameEntry( fn1, fn2, flag );
2693 }
2694
2695 attr = GetFileAttributesW( fn1 );
2696 if ( attr == INVALID_FILE_ATTRIBUTES ) return FALSE;
2697
2698 /* check if we are allowed to rename the source */
2699 hFile = FILE_CreateFile( full_name1.long_name, 0, 0,
2700 NULL, OPEN_EXISTING, 0, 0, TRUE,
2701 GetDriveTypeW( full_name1.short_name ) );
2702 if (!hFile)
2703 {
2704 if (GetLastError() != ERROR_ACCESS_DENIED) return FALSE;
2705 if ( !(attr & FILE_ATTRIBUTE_DIRECTORY) ) return FALSE;
2706 /* if it's a directory we can continue */
2707 }
2708 else CloseHandle(hFile);
2709
2710 /* check, if we are allowed to delete the destination,
2711 ** (but the file not being there is fine) */
2712 hFile = FILE_CreateFile( full_name2.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2713 NULL, OPEN_EXISTING, 0, 0, TRUE,
2714 GetDriveTypeW( full_name2.short_name ) );
2715 if(!hFile && GetLastError() != ERROR_FILE_NOT_FOUND) return FALSE;
2716 CloseHandle(hFile);
2717
2718 if (full_name1.drive != full_name2.drive)
2719 {
2720 if (!(flag & MOVEFILE_COPY_ALLOWED))
2721 {
2722 SetLastError( ERROR_NOT_SAME_DEVICE );
2723 return FALSE;
2724 }
2725 else if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2726 {
2727 /* Strange, but that's what Windows returns */
2728 SetLastError ( ERROR_ACCESS_DENIED );
2729 return FALSE;
2730 }
2731 }
2732 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
2733 /* Try copy/delete unless it's a directory. */
2734 /* FIXME: This does not handle the (unlikely) case that the two locations
2735 are on the same Wine drive, but on different Unix file systems. */
2736 {
2737 if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2738 {
2739 FILE_SetDosError();
2740 return FALSE;
2741 }
2742 else
2743 {
2744 if ( ! CopyFileW( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) ))
2745 return FALSE;
2746 if ( ! DeleteFileW ( fn1 ) )
2747 return FALSE;
2748 }
2749 }
2750 if (is_executable( full_name1.long_name ) != is_executable( full_name2.long_name ))
2751 {
2752 struct stat fstat;
2753 if (stat( full_name2.long_name, &fstat ) != -1)
2754 {
2755 if (is_executable( full_name2.long_name ))
2756 /* set executable bit where read bit is set */
2757 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
2758 else
2759 fstat.st_mode &= ~0111;
2760 chmod( full_name2.long_name, fstat.st_mode );
2761 }
2762 }
2763 return TRUE;
2764 }
2765 else /* fn2 == NULL means delete source */
2766 {
2767 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2768 {
2769 if (flag & MOVEFILE_COPY_ALLOWED) {
2770 WARN("Illegal flag\n");
2771 SetLastError( ERROR_GEN_FAILURE );
2772 return FALSE;
2773 }
2774 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
2775 Perhaps we should queue these command and execute it
2776 when exiting... What about using on_exit(2)
2777 */
2778 FIXME("Please delete file %s when Wine has finished\n", debugstr_w(fn1));
2779 return FILE_AddBootRenameEntry( fn1, NULL, flag );
2780 }
2781
2782 if (unlink( full_name1.long_name ) == -1)
2783 {
2784 FILE_SetDosError();
2785 return FALSE;
2786 }
2787 return TRUE; /* successfully deleted */
2788 }
2789 }
2790
2791 /**************************************************************************
2792 * MoveFileExA (KERNEL32.@)
2793 */
2794 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
2795 {
2796 UNICODE_STRING fn1W, fn2W;
2797 BOOL ret;
2798
2799 if (!fn1)
2800 {
2801 SetLastError(ERROR_INVALID_PARAMETER);
2802 return FALSE;
2803 }
2804
2805 RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
2806 if (fn2) RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
2807 else fn2W.Buffer = NULL;
2808
2809 ret = MoveFileExW( fn1W.Buffer, fn2W.Buffer, flag );
2810
2811 RtlFreeUnicodeString(&fn1W);
2812 RtlFreeUnicodeString(&fn2W);
2813 return ret;
2814 }
2815
2816
2817 /**************************************************************************
2818 * MoveFileW (KERNEL32.@)
2819 *
2820 * Move file or directory
2821 */
2822 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
2823 {
2824 DOS_FULL_NAME full_name1, full_name2;
2825 struct stat fstat;
2826
2827 if (!fn1 || !fn2)
2828 {
2829 SetLastError(ERROR_INVALID_PARAMETER);
2830 return FALSE;
2831 }
2832
2833 TRACE("(%s,%s)\n", debugstr_w(fn1), debugstr_w(fn2) );
2834
2835 if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
2836 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) {
2837 /* The new name must not already exist */
2838 SetLastError(ERROR_ALREADY_EXISTS);
2839 return FALSE;
2840 }
2841 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
2842
2843 if (full_name1.drive == full_name2.drive) /* move */
2844 return MoveFileExW( fn1, fn2, MOVEFILE_COPY_ALLOWED );
2845
2846 /* copy */
2847 if (stat( full_name1.long_name, &fstat ))
2848 {
2849 WARN("Invalid source file %s\n",
2850 full_name1.long_name);
2851 FILE_SetDosError();
2852 return FALSE;
2853 }
2854 if (S_ISDIR(fstat.st_mode)) {
2855 /* No Move for directories across file systems */
2856 /* FIXME: Use right error code */
2857 SetLastError( ERROR_GEN_FAILURE );
2858 return FALSE;
2859 }
2860 return CopyFileW(fn1, fn2, TRUE); /*fail, if exist */
2861 }
2862
2863
2864 /**************************************************************************
2865 * MoveFileA (KERNEL32.@)
2866 */
2867 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
2868 {
2869 UNICODE_STRING fn1W, fn2W;
2870 BOOL ret;
2871
2872 if (!fn1 || !fn2)
2873 {
2874 SetLastError(ERROR_INVALID_PARAMETER);
2875 return FALSE;
2876 }
2877
2878 RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
2879 RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
2880
2881 ret = MoveFileW( fn1W.Buffer, fn2W.Buffer );
2882
2883 RtlFreeUnicodeString(&fn1W);
2884 RtlFreeUnicodeString(&fn2W);
2885 return ret;
2886 }
2887
2888
2889 /**************************************************************************
2890 * CopyFileW (KERNEL32.@)
2891 */
2892 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
2893 {
2894 HANDLE h1, h2;
2895 BY_HANDLE_FILE_INFORMATION info;
2896 DWORD count;
2897 BOOL ret = FALSE;
2898 char buffer[2048];
2899
2900 if (!source || !dest)
2901 {
2902 SetLastError(ERROR_INVALID_PARAMETER);
2903 return FALSE;
2904 }
2905
2906 TRACE("%s -> %s\n", debugstr_w(source), debugstr_w(dest));
2907
2908 if ((h1 = CreateFileW(source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
2909 NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
2910 {
2911 WARN("Unable to open source %s\n", debugstr_w(source));
2912 return FALSE;
2913 }
2914
2915 if (!GetFileInformationByHandle( h1, &info ))
2916 {
2917 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
2918 CloseHandle( h1 );
2919 return FALSE;
2920 }
2921
2922 if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2923 fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
2924 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
2925 {
2926 WARN("Unable to open dest %s\n", debugstr_w(dest));
2927 CloseHandle( h1 );
2928 return FALSE;
2929 }
2930
2931 while (ReadFile( h1, buffer, sizeof(buffer), &count, NULL ) && count)
2932 {
2933 char *p = buffer;
2934 while (count != 0)
2935 {
2936 DWORD res;
2937 if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
2938 p += res;
2939 count -= res;
2940 }
2941 }
2942 ret = TRUE;
2943 done:
2944 CloseHandle( h1 );
2945 CloseHandle( h2 );
2946 return ret;
2947 }
2948
2949
2950 /**************************************************************************
2951 * CopyFileA (KERNEL32.@)
2952 */
2953 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
2954 {
2955 UNICODE_STRING sourceW, destW;
2956 BOOL ret;
2957
2958 if (!source || !dest)
2959 {
2960 SetLastError(ERROR_INVALID_PARAMETER);
2961 return FALSE;
2962 }
2963
2964 RtlCreateUnicodeStringFromAsciiz(&sourceW, source);
2965 RtlCreateUnicodeStringFromAsciiz(&destW, dest);
2966
2967 ret = CopyFileW(sourceW.Buffer, destW.Buffer, fail_if_exists);
2968
2969 RtlFreeUnicodeString(&sourceW);
2970 RtlFreeUnicodeString(&destW);
2971 return ret;
2972 }
2973
2974
2975 /**************************************************************************
2976 * CopyFileExW (KERNEL32.@)
2977 *
2978 * This implementation ignores most of the extra parameters passed-in into
2979 * the "ex" version of the method and calls the CopyFile method.
2980 * It will have to be fixed eventually.
2981 */
2982 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename, LPCWSTR destFilename,
2983 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2984 LPBOOL cancelFlagPointer, DWORD copyFlags)
2985 {
2986 /*
2987 * Interpret the only flag that CopyFile can interpret.
2988 */
2989 return CopyFileW(sourceFilename, destFilename, (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0);
2990 }
2991
2992 /**************************************************************************
2993 * CopyFileExA (KERNEL32.@)
2994 */
2995 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
2996 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2997 LPBOOL cancelFlagPointer, DWORD copyFlags)
2998 {
2999 UNICODE_STRING sourceW, destW;
3000 BOOL ret;
3001
3002 if (!sourceFilename || !destFilename)
3003 {
3004 SetLastError(ERROR_INVALID_PARAMETER);
3005 return FALSE;
3006 }
3007
3008 RtlCreateUnicodeStringFromAsciiz(&sourceW, sourceFilename);
3009 RtlCreateUnicodeStringFromAsciiz(&destW, destFilename);
3010
3011 ret = CopyFileExW(sourceW.Buffer, destW.Buffer, progressRoutine, appData,
3012 cancelFlagPointer, copyFlags);
3013
3014 RtlFreeUnicodeString(&sourceW);
3015 RtlFreeUnicodeString(&destW);
3016 return ret;
3017 }
3018
3019
3020 /***********************************************************************
3021 * SetFileTime (KERNEL32.@)
3022 */
3023 BOOL WINAPI SetFileTime( HANDLE hFile,
3024 const FILETIME *lpCreationTime,
3025 const FILETIME *lpLastAccessTime,
3026 const FILETIME *lpLastWriteTime )
3027 {
3028 BOOL ret;
3029 SERVER_START_REQ( set_file_time )
3030 {
3031 req->handle = hFile;
3032 if (lpLastAccessTime)
3033 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastAccessTime, (DWORD *)&req->access_time );
3034 else
3035 req->access_time = 0; /* FIXME */
3036 if (lpLastWriteTime)
3037 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastWriteTime, (DWORD *)&req->write_time );
3038 else
3039 req->write_time = 0; /* FIXME */
3040 ret = !wine_server_call_err( req );
3041 }
3042 SERVER_END_REQ;
3043 return ret;
3044 }
3045
3046
3047 /**************************************************************************
3048 * LockFile (KERNEL32.@)
3049 */
3050 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
3051 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
3052 {
3053 BOOL ret;
3054
3055 FIXME("not implemented in server\n");
3056
3057 SERVER_START_REQ( lock_file )
3058 {
3059 req->handle = hFile;
3060 req->offset_low = dwFileOffsetLow;
3061 req->offset_high = dwFileOffsetHigh;
3062 req->count_low = nNumberOfBytesToLockLow;
3063 req->count_high = nNumberOfBytesToLockHigh;
3064 ret = !wine_server_call_err( req );
3065 }
3066 SERVER_END_REQ;
3067 return ret;
3068 }
3069
3070 /**************************************************************************
3071 * LockFileEx [KERNEL32.@]
3072 *
3073 * Locks a byte range within an open file for shared or exclusive access.
3074 *
3075 * RETURNS
3076 * success: TRUE
3077 * failure: FALSE
3078 *
3079 * NOTES
3080 * Per Microsoft docs, the third parameter (reserved) must be set to 0.
3081 */
3082 BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
3083 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
3084 LPOVERLAPPED pOverlapped )
3085 {
3086 FIXME("hFile=%d,flags=%ld,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
3087 hFile, flags, reserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh,
3088 pOverlapped);
3089 if (reserved == 0)
3090 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3091 else
3092 {
3093 ERR("reserved == %ld: Supposed to be 0??\n", reserved);
3094 SetLastError(ERROR_INVALID_PARAMETER);
3095 }
3096
3097 return FALSE;
3098 }
3099
3100
3101 /**************************************************************************
3102 * UnlockFile (KERNEL32.@)
3103 */
3104 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
3105 DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
3106 {
3107 BOOL ret;
3108
3109 FIXME("not implemented in server\n");
3110
3111 SERVER_START_REQ( unlock_file )
3112 {
3113 req->handle = hFile;
3114 req->offset_low = dwFileOffsetLow;
3115 req->offset_high = dwFileOffsetHigh;
3116 req->count_low = nNumberOfBytesToUnlockLow;
3117 req->count_high = nNumberOfBytesToUnlockHigh;
3118 ret = !wine_server_call_err( req );
3119 }
3120 SERVER_END_REQ;
3121 return ret;
3122 }
3123
3124
3125 /**************************************************************************
3126 * UnlockFileEx (KERNEL32.@)
3127 */
3128 BOOL WINAPI UnlockFileEx(
3129 HANDLE hFile,
3130 DWORD dwReserved,
3131 DWORD nNumberOfBytesToUnlockLow,
3132 DWORD nNumberOfBytesToUnlockHigh,
3133 LPOVERLAPPED lpOverlapped
3134 )
3135 {
3136 FIXME("hFile=%d,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
3137 hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh,
3138 lpOverlapped);
3139 if (dwReserved == 0)
3140 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3141 else
3142 {
3143 ERR("reserved == %ld: Supposed to be 0??\n", dwReserved);
3144 SetLastError(ERROR_INVALID_PARAMETER);
3145 }
3146
3147 return FALSE;
3148 }
3149
3150
3151 #if 0
3152
3153 struct DOS_FILE_LOCK {
3154 struct DOS_FILE_LOCK * next;
3155 DWORD base;
3156 DWORD len;
3157 DWORD processId;
3158 FILE_OBJECT * dos_file;
3159 /* char * unix_name;*/
3160 };
3161
3162 typedef struct DOS_FILE_LOCK DOS_FILE_LOCK;
3163
3164 static DOS_FILE_LOCK *locks = NULL;
3165 static void DOS_RemoveFileLocks(FILE_OBJECT *file);
3166
3167
3168 /* Locks need to be mirrored because unix file locking is based
3169 * on the pid. Inside of wine there can be multiple WINE processes
3170 * that share the same unix pid.
3171 * Read's and writes should check these locks also - not sure
3172 * how critical that is at this point (FIXME).
3173 */
3174
3175 static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
3176 {
3177 DOS_FILE_LOCK *curr;
3178 DWORD processId;
3179
3180 processId = GetCurrentProcessId();
3181
3182 /* check if lock overlaps a current lock for the same file */
3183 #if 0
3184 for (curr = locks; curr; curr = curr->next) {
3185 if (strcmp(curr->unix_name, file->unix_name) == 0) {
3186 if ((f->l_start == curr->base) && (f->l_len == curr->len))
3187 return TRUE;/* region is identic */
3188 if ((f->l_start < (curr->base + curr->len)) &&
3189 ((f->l_start + f->l_len) > curr->base)) {
3190 /* region overlaps */
3191 return FALSE;
3192 }
3193 }
3194 }
3195 #endif
3196
3197 curr = HeapAlloc( GetProcessHeap(), 0, sizeof(DOS_FILE_LOCK) );
3198 curr->processId = GetCurrentProcessId();
3199 curr->base = f->l_start;
3200 curr->len = f->l_len;
3201 /* curr->unix_name = HEAP_strdupA( GetProcessHeap(), 0, file->unix_name);*/
3202 curr->next = locks;
3203 curr->dos_file = file;
3204 locks = curr;
3205 return TRUE;
3206 }
3207
3208 static void DOS_RemoveFileLocks(FILE_OBJECT *file)
3209 {
3210 DWORD processId;
3211 DOS_FILE_LOCK **curr;
3212 DOS_FILE_LOCK *rem;
3213
3214 processId = GetCurrentProcessId();
3215 curr = &locks;
3216 while (*curr) {
3217 if ((*curr)->dos_file == file) {
3218 rem = *curr;
3219 *curr = (*curr)->next;
3220 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
3221 HeapFree( GetProcessHeap(), 0, rem );
3222 }
3223 else
3224 curr = &(*curr)->next;
3225 }
3226 }
3227
3228 static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
3229 {
3230 DWORD processId;
3231 DOS_FILE_LOCK **curr;
3232 DOS_FILE_LOCK *rem;
3233
3234 processId = GetCurrentProcessId();
3235 for (curr = &locks; *curr; curr = &(*curr)->next) {
3236 if ((*curr)->processId == processId &&
3237 (*curr)->dos_file == file &&
3238 (*curr)->base == f->l_start &&
3239 (*curr)->len == f->l_len) {
3240 /* this is the same lock */
3241 rem = *curr;
3242 *curr = (*curr)->next;
3243 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
3244 HeapFree( GetProcessHeap(), 0, rem );
3245 return TRUE;
3246 }
3247 }
3248 /* no matching lock found */
3249 return FALSE;
3250 }
3251
3252
3253 /**************************************************************************
3254 * LockFile (KERNEL32.@)
3255 */
3256 BOOL WINAPI LockFile(
3257 HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
3258 DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
3259 {
3260 struct flock f;
3261 FILE_OBJECT *file;
3262
3263 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
3264 hFile, dwFileOffsetLow, dwFileOffsetHigh,
3265 nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh);
3266
3267 if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) {
3268 FIXME("Unimplemented bytes > 32bits\n");
3269 return FALSE;
3270 }
3271
3272 f.l_start = dwFileOffsetLow;
3273 f.l_len = nNumberOfBytesToLockLow;
3274 f.l_whence = SEEK_SET;
3275 f.l_pid = 0;
3276 f.l_type = F_WRLCK;
3277
3278 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
3279
3280 /* shadow locks internally */
3281 if (!DOS_AddLock(file, &f)) {
3282 SetLastError( ERROR_LOCK_VIOLATION );
3283 return FALSE;
3284 }
3285
3286 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
3287 #ifdef USE_UNIX_LOCKS
3288 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
3289 if (errno == EACCES || errno == EAGAIN) {
3290 SetLastError( ERROR_LOCK_VIOLATION );
3291 }
3292 else {
3293 FILE_SetDosError();
3294 }
3295 /* remove our internal copy of the lock */
3296 DOS_RemoveLock(file, &f);
3297 return FALSE;
3298 }
3299 #endif
3300 return TRUE;
3301 }
3302
3303
3304 /**************************************************************************
3305 * UnlockFile (KERNEL32.@)
3306 */
3307 BOOL WINAPI UnlockFile(
3308 HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
3309 DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
3310 {
3311 FILE_OBJECT *file;
3312 struct flock f;
3313
3314 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
3315 hFile, dwFileOffsetLow, dwFileOffsetHigh,
3316 nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);
3317
3318 if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) {
3319 WARN("Unimplemented bytes > 32bits\n");
3320 return FALSE;
3321 }
3322
3323 f.l_start = dwFileOffsetLow;
3324 f.l_len = nNumberOfBytesToUnlockLow;
3325 f.l_whence = SEEK_SET;
3326 f.l_pid = 0;
3327 f.l_type = F_UNLCK;
3328
3329 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
3330
3331 DOS_RemoveLock(file, &f); /* ok if fails - may be another wine */
3332
3333 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
3334 #ifdef USE_UNIX_LOCKS
3335 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
3336 FILE_SetDosError();
3337 return FALSE;
3338 }
3339 #endif
3340 return TRUE;
3341 }
3342 #endif
3343
3344 /**************************************************************************
3345 * GetFileAttributesExW (KERNEL32.@)
3346 */
3347 BOOL WINAPI GetFileAttributesExW(
3348 LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
3349 LPVOID lpFileInformation)
3350 {
3351 DOS_FULL_NAME full_name;
3352 BY_HANDLE_FILE_INFORMATION info;
3353
3354 if (!lpFileName || !lpFileInformation)
3355 {
3356 SetLastError(ERROR_INVALID_PARAMETER);
3357 return FALSE;
3358 }
3359
3360 if (fInfoLevelId == GetFileExInfoStandard) {
3361 LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
3362 (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
3363 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
3364 if (!FILE_Stat( full_name.long_name, &info )) return FALSE;
3365
3366 lpFad->dwFileAttributes = info.dwFileAttributes;
3367 lpFad->ftCreationTime = info.ftCreationTime;
3368 lpFad->ftLastAccessTime = info.ftLastAccessTime;
3369 lpFad->ftLastWriteTime = info.ftLastWriteTime;
3370 lpFad->nFileSizeHigh = info.nFileSizeHigh;
3371 lpFad->nFileSizeLow = info.nFileSizeLow;
3372 }
3373 else {
3374 FIXME("invalid info level %d!\n", fInfoLevelId);
3375 return FALSE;
3376 }
3377
3378 return TRUE;
3379 }
3380
3381
3382 /**************************************************************************
3383 * GetFileAttributesExA (KERNEL32.@)
3384 */
3385 BOOL WINAPI GetFileAttributesExA(
3386 LPCSTR filename, GET_FILEEX_INFO_LEVELS fInfoLevelId,
3387 LPVOID lpFileInformation)
3388 {
3389 UNICODE_STRING filenameW;
3390 BOOL ret = FALSE;
3391
3392 if (!filename || !lpFileInformation)
3393 {
3394 SetLastError(ERROR_INVALID_PARAMETER);
3395 return FALSE;
3396 }
3397
3398 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
3399 {
3400 ret = GetFileAttributesExW(filenameW.Buffer, fInfoLevelId, lpFileInformation);
3401 RtlFreeUnicodeString(&filenameW);
3402 }
3403 else
3404 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3405 return ret;
3406 }
DirectPlay implementation for GSoC