?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed compile warning.
[wine/multimedia.git] / files / file.c
blob875a64de461749c4393e6a89dc873a3a7acf929b
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 <stdarg.h>
35 #include <stdio.h>
36 #include <string.h>
37 #ifdef HAVE_SYS_ERRNO_H
38 #include <sys/errno.h>
39 #endif
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #ifdef HAVE_SYS_MMAN_H
43 #include <sys/mman.h>
44 #endif
45 #ifdef HAVE_SYS_TIME_H
46 # include <sys/time.h>
47 #endif
48 #ifdef HAVE_SYS_POLL_H
49 # include <sys/poll.h>
50 #endif
51 #include <time.h>
52 #ifdef HAVE_UNISTD_H
53 # include <unistd.h>
54 #endif
55 #ifdef HAVE_UTIME_H
56 # include <utime.h>
57 #endif
58
59 #define NONAMELESSUNION
60 #define NONAMELESSSTRUCT
61 #include "winerror.h"
62 #include "ntstatus.h"
63 #include "windef.h"
64 #include "winbase.h"
65 #include "winreg.h"
66 #include "winternl.h"
67 #include "wine/winbase16.h"
68 #include "wine/server.h"
69
70 #include "drive.h"
71 #include "file.h"
72 #include "heap.h"
73 #include "msdos.h"
74 #include "wincon.h"
75 #include "../kernel/kernel_private.h"
76
77 #include "smb.h"
78 #include "wine/unicode.h"
79 #include "wine/debug.h"
80
81 WINE_DEFAULT_DEBUG_CHANNEL(file);
82
83 #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
84 #define MAP_ANON MAP_ANONYMOUS
85 #endif
86
87 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
88
89 HANDLE dos_handles[DOS_TABLE_SIZE];
90 mode_t FILE_umask;
91
92 /***********************************************************************
93 * FILE_ConvertOFMode
94 *
95 * Convert OF_* mode into flags for CreateFile.
96 */
97 void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
98 {
99 switch(mode & 0x03)
100 {
101 case OF_READ: *access = GENERIC_READ; break;
102 case OF_WRITE: *access = GENERIC_WRITE; break;
103 case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
104 default: *access = 0; break;
105 }
106 switch(mode & 0x70)
107 {
108 case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
109 case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
110 case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
111 case OF_SHARE_DENY_NONE:
112 case OF_SHARE_COMPAT:
113 default: *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
114 }
115 }
116
117
118 /***********************************************************************
119 * FILE_strcasecmp
120 *
121 * locale-independent case conversion for file I/O
122 */
123 int FILE_strcasecmp( const char *str1, const char *str2 )
124 {
125 int ret = 0;
126 for ( ; ; str1++, str2++)
127 if ((ret = FILE_toupper(*str1) - FILE_toupper(*str2)) || !*str1) break;
128 return ret;
129 }
130
131
132 /***********************************************************************
133 * FILE_strncasecmp
134 *
135 * locale-independent case conversion for file I/O
136 */
137 int FILE_strncasecmp( const char *str1, const char *str2, int len )
138 {
139 int ret = 0;
140 for ( ; len > 0; len--, str1++, str2++)
141 if ((ret = FILE_toupper(*str1) - FILE_toupper(*str2)) || !*str1) break;
142 return ret;
143 }
144
145
146 /***********************************************************************
147 * FILE_SetDosError
148 *
149 * Set the DOS error code from errno.
150 */
151 void FILE_SetDosError(void)
152 {
153 int save_errno = errno; /* errno gets overwritten by printf */
154
155 TRACE("errno = %d %s\n", errno, strerror(errno));
156 switch (save_errno)
157 {
158 case EAGAIN:
159 SetLastError( ERROR_SHARING_VIOLATION );
160 break;
161 case EBADF:
162 SetLastError( ERROR_INVALID_HANDLE );
163 break;
164 case ENOSPC:
165 SetLastError( ERROR_HANDLE_DISK_FULL );
166 break;
167 case EACCES:
168 case EPERM:
169 case EROFS:
170 SetLastError( ERROR_ACCESS_DENIED );
171 break;
172 case EBUSY:
173 SetLastError( ERROR_LOCK_VIOLATION );
174 break;
175 case ENOENT:
176 SetLastError( ERROR_FILE_NOT_FOUND );
177 break;
178 case EISDIR:
179 SetLastError( ERROR_CANNOT_MAKE );
180 break;
181 case ENFILE:
182 case EMFILE:
183 SetLastError( ERROR_NO_MORE_FILES );
184 break;
185 case EEXIST:
186 SetLastError( ERROR_FILE_EXISTS );
187 break;
188 case EINVAL:
189 case ESPIPE:
190 SetLastError( ERROR_SEEK );
191 break;
192 case ENOTEMPTY:
193 SetLastError( ERROR_DIR_NOT_EMPTY );
194 break;
195 case ENOEXEC:
196 SetLastError( ERROR_BAD_FORMAT );
197 break;
198 default:
199 WARN("unknown file error: %s\n", strerror(save_errno) );
200 SetLastError( ERROR_GEN_FAILURE );
201 break;
202 }
203 errno = save_errno;
204 }
205
206
207 /***********************************************************************
208 * FILE_GetUnixHandleType
209 *
210 * Retrieve the Unix handle corresponding to a file handle.
211 * Returns -1 on failure.
212 */
213 static int FILE_GetUnixHandleType( HANDLE handle, DWORD access, enum fd_type *type, int *flags_ptr )
214 {
215 int ret, flags, fd = -1;
216
217 ret = wine_server_handle_to_fd( handle, access, &fd, type, &flags );
218 if (flags_ptr) *flags_ptr = flags;
219 if (ret) SetLastError( RtlNtStatusToDosError(ret) );
220 else if (((access & GENERIC_READ) && (flags & FD_FLAG_RECV_SHUTDOWN)) ||
221 ((access & GENERIC_WRITE) && (flags & FD_FLAG_SEND_SHUTDOWN)))
222 {
223 close (fd);
224 SetLastError ( ERROR_PIPE_NOT_CONNECTED );
225 return -1;
226 }
227 return fd;
228 }
229
230 /***********************************************************************
231 * FILE_GetUnixHandle
232 *
233 * Retrieve the Unix handle corresponding to a file handle.
234 * Returns -1 on failure.
235 */
236 int FILE_GetUnixHandle( HANDLE handle, DWORD access )
237 {
238 return FILE_GetUnixHandleType( handle, access, NULL, NULL );
239 }
240
241 /******************************************************************
242 * OpenConsoleW (KERNEL32.@)
243 *
244 * Undocumented
245 * Open a handle to the current process console.
246 * Returns INVALID_HANDLE_VALUE on failure.
247 */
248 HANDLE WINAPI OpenConsoleW(LPCWSTR name, DWORD access, LPSECURITY_ATTRIBUTES sa,
249 DWORD creation)
250 {
251 static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
252 static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
253 BOOL output;
254 HANDLE ret;
255
256 if (strcmpW(coninW, name) == 0)
257 output = FALSE;
258 else if (strcmpW(conoutW, name) == 0)
259 output = TRUE;
260 else
261 {
262 SetLastError(ERROR_INVALID_NAME);
263 return INVALID_HANDLE_VALUE;
264 }
265 if (creation != OPEN_EXISTING)
266 {
267 SetLastError(ERROR_INVALID_PARAMETER);
268 return INVALID_HANDLE_VALUE;
269 }
270
271 SERVER_START_REQ( open_console )
272 {
273 req->from = output;
274 req->access = access;
275 req->share = FILE_SHARE_READ | FILE_SHARE_WRITE;
276 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
277 SetLastError(0);
278 wine_server_call_err( req );
279 ret = reply->handle;
280 }
281 SERVER_END_REQ;
282 return ret ? console_handle_map(ret) : INVALID_HANDLE_VALUE;
283 }
284
285 /******************************************************************
286 * VerifyConsoleIoHandle (KERNEL32.@)
287 *
288 * Undocumented
289 */
290 BOOL WINAPI VerifyConsoleIoHandle(HANDLE handle)
291 {
292 BOOL ret;
293
294 if (!is_console_handle(handle)) return FALSE;
295 SERVER_START_REQ(get_console_mode)
296 {
297 req->handle = console_handle_unmap(handle);
298 ret = !wine_server_call_err( req );
299 }
300 SERVER_END_REQ;
301 return ret;
302 }
303
304 /******************************************************************
305 * DuplicateConsoleHandle (KERNEL32.@)
306 *
307 * Undocumented
308 */
309 HANDLE WINAPI DuplicateConsoleHandle(HANDLE handle, DWORD access, BOOL inherit,
310 DWORD options)
311 {
312 HANDLE ret;
313
314 if (!is_console_handle(handle) ||
315 !DuplicateHandle(GetCurrentProcess(), console_handle_unmap(handle),
316 GetCurrentProcess(), &ret, access, inherit, options))
317 return INVALID_HANDLE_VALUE;
318 return console_handle_map(ret);
319 }
320
321 /******************************************************************
322 * CloseConsoleHandle (KERNEL32.@)
323 *
324 * Undocumented
325 */
326 BOOL WINAPI CloseConsoleHandle(HANDLE handle)
327 {
328 if (!is_console_handle(handle))
329 {
330 SetLastError(ERROR_INVALID_PARAMETER);
331 return FALSE;
332 }
333 return CloseHandle(console_handle_unmap(handle));
334 }
335
336 /******************************************************************
337 * GetConsoleInputWaitHandle (KERNEL32.@)
338 *
339 * Undocumented
340 */
341 HANDLE WINAPI GetConsoleInputWaitHandle(void)
342 {
343 static HANDLE console_wait_event;
344
345 /* FIXME: this is not thread safe */
346 if (!console_wait_event)
347 {
348 SERVER_START_REQ(get_console_wait_event)
349 {
350 if (!wine_server_call_err( req )) console_wait_event = reply->handle;
351 }
352 SERVER_END_REQ;
353 }
354 return console_wait_event;
355 }
356 /* end of FIXME */
357
358
359 /* FIXME: those routines defined as pointers are needed, because this file is
360 * currently compiled into NTDLL whereas it belongs to kernel32.
361 * this shall go away once all the DLL separation process is done
362 */
363 typedef BOOL (WINAPI* pRW)(HANDLE, const void*, DWORD, DWORD*, void*);
364
365 static BOOL FILE_ReadConsole(HANDLE hCon, void* buf, DWORD nb, DWORD* nr, void* p)
366 {
367 static HANDLE hKernel /* = 0 */;
368 static pRW pReadConsole /* = 0 */;
369
370 if ((!hKernel && !(hKernel = LoadLibraryA("kernel32"))) ||
371 (!pReadConsole &&
372 !(pReadConsole = GetProcAddress(hKernel, "ReadConsoleA"))))
373 {
374 *nr = 0;
375 return 0;
376 }
377 return (pReadConsole)(hCon, buf, nb, nr, p);
378 }
379
380 static BOOL FILE_WriteConsole(HANDLE hCon, const void* buf, DWORD nb, DWORD* nr, void* p)
381 {
382 static HANDLE hKernel /* = 0 */;
383 static pRW pWriteConsole /* = 0 */;
384
385 if ((!hKernel && !(hKernel = LoadLibraryA("kernel32"))) ||
386 (!pWriteConsole &&
387 !(pWriteConsole = GetProcAddress(hKernel, "WriteConsoleA"))))
388 {
389 *nr = 0;
390 return 0;
391 }
392 return (pWriteConsole)(hCon, buf, nb, nr, p);
393 }
394 /* end of FIXME */
395
396 /***********************************************************************
397 * FILE_CreateFile
398 *
399 * Implementation of CreateFile. Takes a Unix path name.
400 * Returns 0 on failure.
401 */
402 HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
403 LPSECURITY_ATTRIBUTES sa, DWORD creation,
404 DWORD attributes, HANDLE template, BOOL fail_read_only,
405 UINT drive_type )
406 {
407 unsigned int err;
408 HANDLE ret;
409
410 for (;;)
411 {
412 SERVER_START_REQ( create_file )
413 {
414 req->access = access;
415 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
416 req->sharing = sharing;
417 req->create = creation;
418 req->attrs = attributes;
419 req->drive_type = drive_type;
420 wine_server_add_data( req, filename, strlen(filename) );
421 SetLastError(0);
422 err = wine_server_call( req );
423 ret = reply->handle;
424 }
425 SERVER_END_REQ;
426
427 /* If write access failed, retry without GENERIC_WRITE */
428
429 if (!ret && !fail_read_only && (access & GENERIC_WRITE))
430 {
431 if ((err == STATUS_MEDIA_WRITE_PROTECTED) || (err == STATUS_ACCESS_DENIED))
432 {
433 TRACE("Write access failed for file '%s', trying without "
434 "write access\n", filename);
435 access &= ~GENERIC_WRITE;
436 continue;
437 }
438 }
439
440 if (err)
441 {
442 /* In the case file creation was rejected due to CREATE_NEW flag
443 * was specified and file with that name already exists, correct
444 * last error is ERROR_FILE_EXISTS and not ERROR_ALREADY_EXISTS.
445 * Note: RtlNtStatusToDosError is not the subject to blame here.
446 */
447 if (err == STATUS_OBJECT_NAME_COLLISION)
448 SetLastError( ERROR_FILE_EXISTS );
449 else
450 SetLastError( RtlNtStatusToDosError(err) );
451 }
452
453 if (!ret) WARN("Unable to create file '%s' (GLE %ld)\n", filename, GetLastError());
454 return ret;
455 }
456 }
457
458
459 /***********************************************************************
460 * FILE_CreateDevice
461 *
462 * Same as FILE_CreateFile but for a device
463 * Returns 0 on failure.
464 */
465 HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
466 {
467 HANDLE ret;
468 SERVER_START_REQ( create_device )
469 {
470 req->access = access;
471 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
472 req->id = client_id;
473 SetLastError(0);
474 wine_server_call_err( req );
475 ret = reply->handle;
476 }
477 SERVER_END_REQ;
478 return ret;
479 }
480
481 static HANDLE FILE_OpenPipe(LPCWSTR name, DWORD access, LPSECURITY_ATTRIBUTES sa )
482 {
483 HANDLE ret;
484 DWORD len = 0;
485
486 if (name && (len = strlenW(name)) > MAX_PATH)
487 {
488 SetLastError( ERROR_FILENAME_EXCED_RANGE );
489 return 0;
490 }
491 SERVER_START_REQ( open_named_pipe )
492 {
493 req->access = access;
494 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
495 SetLastError(0);
496 wine_server_add_data( req, name, len * sizeof(WCHAR) );
497 wine_server_call_err( req );
498 ret = reply->handle;
499 }
500 SERVER_END_REQ;
501 TRACE("Returned %p\n",ret);
502 return ret;
503 }
504
505 /*************************************************************************
506 * CreateFileW [KERNEL32.@] Creates or opens a file or other object
507 *
508 * Creates or opens an object, and returns a handle that can be used to
509 * access that object.
510 *
511 * PARAMS
512 *
513 * filename [in] pointer to filename to be accessed
514 * access [in] access mode requested
515 * sharing [in] share mode
516 * sa [in] pointer to security attributes
517 * creation [in] how to create the file
518 * attributes [in] attributes for newly created file
519 * template [in] handle to file with extended attributes to copy
520 *
521 * RETURNS
522 * Success: Open handle to specified file
523 * Failure: INVALID_HANDLE_VALUE
524 *
525 * NOTES
526 * Should call SetLastError() on failure.
527 *
528 * BUGS
529 *
530 * Doesn't support character devices, template files, or a
531 * lot of the 'attributes' flags yet.
532 */
533 HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
534 LPSECURITY_ATTRIBUTES sa, DWORD creation,
535 DWORD attributes, HANDLE template )
536 {
537 DOS_FULL_NAME full_name;
538 HANDLE ret;
539 static const WCHAR bkslashes_with_question_markW[] = {'\\','\\','?','\\',0};
540 static const WCHAR bkslashes_with_dotW[] = {'\\','\\','.','\\',0};
541 static const WCHAR bkslashesW[] = {'\\','\\',0};
542 static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
543 static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
544
545 if (!filename)
546 {
547 SetLastError( ERROR_INVALID_PARAMETER );
548 return INVALID_HANDLE_VALUE;
549 }
550 TRACE("%s %s%s%s%s%s%s%s attributes 0x%lx\n", debugstr_w(filename),
551 ((access & GENERIC_READ)==GENERIC_READ)?"GENERIC_READ ":"",
552 ((access & GENERIC_WRITE)==GENERIC_WRITE)?"GENERIC_WRITE ":"",
553 (!access)?"QUERY_ACCESS ":"",
554 ((sharing & FILE_SHARE_READ)==FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
555 ((sharing & FILE_SHARE_WRITE)==FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
556 ((sharing & FILE_SHARE_DELETE)==FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
557 (creation ==CREATE_NEW)?"CREATE_NEW":
558 (creation ==CREATE_ALWAYS)?"CREATE_ALWAYS ":
559 (creation ==OPEN_EXISTING)?"OPEN_EXISTING ":
560 (creation ==OPEN_ALWAYS)?"OPEN_ALWAYS ":
561 (creation ==TRUNCATE_EXISTING)?"TRUNCATE_EXISTING ":"", attributes);
562
563 /* If the name starts with '\\?\', ignore the first 4 chars. */
564 if (!strncmpW(filename, bkslashes_with_question_markW, 4))
565 {
566 static const WCHAR uncW[] = {'U','N','C','\\',0};
567 filename += 4;
568 if (!strncmpiW(filename, uncW, 4))
569 {
570 FIXME("UNC name (%s) not supported.\n", debugstr_w(filename) );
571 SetLastError( ERROR_PATH_NOT_FOUND );
572 return INVALID_HANDLE_VALUE;
573 }
574 }
575
576 if (!strncmpW(filename, bkslashes_with_dotW, 4))
577 {
578 static const WCHAR pipeW[] = {'P','I','P','E','\\',0};
579 if(!strncmpiW(filename + 4, pipeW, 5))
580 {
581 TRACE("Opening a pipe: %s\n", debugstr_w(filename));
582 ret = FILE_OpenPipe( filename, access, sa );
583 goto done;
584 }
585 else if (isalphaW(filename[4]) && filename[5] == ':' && filename[6] == '\0')
586 {
587 ret = FILE_CreateDevice( (toupperW(filename[4]) - 'A') | 0x20000, access, sa );
588 goto done;
589 }
590 else if (!DOSFS_GetDevice( filename ))
591 {
592 ret = DEVICE_Open( filename+4, access, sa );
593 goto done;
594 }
595 else
596 filename+=4; /* fall into DOSFS_Device case below */
597 }
598
599 /* If the name still starts with '\\', it's a UNC name. */
600 if (!strncmpW(filename, bkslashesW, 2))
601 {
602 ret = SMB_CreateFileW(filename, access, sharing, sa, creation, attributes, template );
603 goto done;
604 }
605
606 /* If the name contains a DOS wild card (* or ?), do no create a file */
607 if(strchrW(filename, '*') || strchrW(filename, '?'))
608 {
609 SetLastError(ERROR_BAD_PATHNAME);
610 return INVALID_HANDLE_VALUE;
611 }
612
613 /* Open a console for CONIN$ or CONOUT$ */
614 if (!strcmpiW(filename, coninW) || !strcmpiW(filename, conoutW))
615 {
616 ret = OpenConsoleW(filename, access, sa, creation);
617 goto done;
618 }
619
620 if (DOSFS_GetDevice( filename ))
621 {
622 TRACE("opening device %s\n", debugstr_w(filename) );
623
624 if (!(ret = DOSFS_OpenDevice( filename, access, attributes, sa )))
625 {
626 /* Do not silence this please. It is a critical error. -MM */
627 ERR("Couldn't open device %s!\n", debugstr_w(filename));
628 SetLastError( ERROR_FILE_NOT_FOUND );
629 }
630 goto done;
631 }
632
633 /* check for filename, don't check for last entry if creating */
634 if (!DOSFS_GetFullName( filename,
635 (creation == OPEN_EXISTING) ||
636 (creation == TRUNCATE_EXISTING),
637 &full_name )) {
638 WARN("Unable to get full filename from %s (GLE %ld)\n",
639 debugstr_w(filename), GetLastError());
640 return INVALID_HANDLE_VALUE;
641 }
642
643 ret = FILE_CreateFile( full_name.long_name, access, sharing,
644 sa, creation, attributes, template,
645 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY,
646 GetDriveTypeW( full_name.short_name ) );
647 done:
648 if (!ret) ret = INVALID_HANDLE_VALUE;
649 TRACE("returning %p\n", ret);
650 return ret;
651 }
652
653
654
655 /*************************************************************************
656 * CreateFileA (KERNEL32.@)
657 */
658 HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
659 LPSECURITY_ATTRIBUTES sa, DWORD creation,
660 DWORD attributes, HANDLE template)
661 {
662 UNICODE_STRING filenameW;
663 HANDLE ret = INVALID_HANDLE_VALUE;
664
665 if (!filename)
666 {
667 SetLastError( ERROR_INVALID_PARAMETER );
668 return INVALID_HANDLE_VALUE;
669 }
670
671 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
672 {
673 ret = CreateFileW(filenameW.Buffer, access, sharing, sa, creation,
674 attributes, template);
675 RtlFreeUnicodeString(&filenameW);
676 }
677 else
678 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
679 return ret;
680 }
681
682
683 /***********************************************************************
684 * FILE_FillInfo
685 *
686 * Fill a file information from a struct stat.
687 */
688 static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
689 {
690 if (S_ISDIR(st->st_mode))
691 info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
692 else
693 info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
694 if (!(st->st_mode & S_IWUSR))
695 info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
696
697 RtlSecondsSince1970ToTime( st->st_mtime, (LARGE_INTEGER *)&info->ftCreationTime );
698 RtlSecondsSince1970ToTime( st->st_mtime, (LARGE_INTEGER *)&info->ftLastWriteTime );
699 RtlSecondsSince1970ToTime( st->st_atime, (LARGE_INTEGER *)&info->ftLastAccessTime );
700
701 info->dwVolumeSerialNumber = 0; /* FIXME */
702 info->nFileSizeHigh = 0;
703 info->nFileSizeLow = 0;
704 if (!S_ISDIR(st->st_mode)) {
705 info->nFileSizeHigh = st->st_size >> 32;
706 info->nFileSizeLow = st->st_size & 0xffffffff;
707 }
708 info->nNumberOfLinks = st->st_nlink;
709 info->nFileIndexHigh = 0;
710 info->nFileIndexLow = st->st_ino;
711 }
712
713
714 /***********************************************************************
715 * get_show_dot_files_option
716 */
717 static BOOL get_show_dot_files_option(void)
718 {
719 static const WCHAR WineW[] = {'M','a','c','h','i','n','e','\\',
720 'S','o','f','t','w','a','r','e','\\',
721 'W','i','n','e','\\','W','i','n','e','\\',
722 'C','o','n','f','i','g','\\','W','i','n','e',0};
723 static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
724
725 char tmp[80];
726 HKEY hkey;
727 DWORD dummy;
728 OBJECT_ATTRIBUTES attr;
729 UNICODE_STRING nameW;
730 BOOL ret = FALSE;
731
732 attr.Length = sizeof(attr);
733 attr.RootDirectory = 0;
734 attr.ObjectName = &nameW;
735 attr.Attributes = 0;
736 attr.SecurityDescriptor = NULL;
737 attr.SecurityQualityOfService = NULL;
738 RtlInitUnicodeString( &nameW, WineW );
739
740 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
741 {
742 RtlInitUnicodeString( &nameW, ShowDotFilesW );
743 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
744 {
745 WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
746 ret = IS_OPTION_TRUE( str[0] );
747 }
748 NtClose( hkey );
749 }
750 return ret;
751 }
752
753
754 /***********************************************************************
755 * FILE_Stat
756 *
757 * Stat a Unix path name. Return TRUE if OK.
758 */
759 BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info, BOOL *is_symlink_ptr )
760 {
761 struct stat st;
762 int is_symlink;
763 LPCSTR p;
764
765 if (lstat( unixName, &st ) == -1)
766 {
767 FILE_SetDosError();
768 return FALSE;
769 }
770 is_symlink = S_ISLNK(st.st_mode);
771 if (is_symlink)
772 {
773 /* do a "real" stat to find out
774 about the type of the symlink destination */
775 if (stat( unixName, &st ) == -1)
776 {
777 FILE_SetDosError();
778 return FALSE;
779 }
780 }
781
782 /* fill in the information we gathered so far */
783 FILE_FillInfo( &st, info );
784
785 /* and now see if this is a hidden file, based on the name */
786 p = strrchr( unixName, '/');
787 p = p ? p + 1 : unixName;
788 if (*p == '.' && *(p+1) && (*(p+1) != '.' || *(p+2)))
789 {
790 static int show_dot_files = -1;
791 if (show_dot_files == -1)
792 show_dot_files = get_show_dot_files_option();
793 if (!show_dot_files)
794 info->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
795 }
796 if (is_symlink_ptr) *is_symlink_ptr = is_symlink;
797 return TRUE;
798 }
799
800
801 /***********************************************************************
802 * GetFileInformationByHandle (KERNEL32.@)
803 */
804 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
805 BY_HANDLE_FILE_INFORMATION *info )
806 {
807 DWORD ret;
808 if (!info) return 0;
809
810 TRACE("%p\n", hFile);
811
812 SERVER_START_REQ( get_file_info )
813 {
814 req->handle = hFile;
815 if ((ret = !wine_server_call_err( req )))
816 {
817 /* FIXME: which file types are supported ?
818 * Serial ports (FILE_TYPE_CHAR) are not,
819 * and MSDN also says that pipes are not supported.
820 * FILE_TYPE_REMOTE seems to be supported according to
821 * MSDN q234741.txt */
822 if ((reply->type == FILE_TYPE_DISK) || (reply->type == FILE_TYPE_REMOTE))
823 {
824 RtlSecondsSince1970ToTime( reply->write_time, (LARGE_INTEGER *)&info->ftCreationTime );
825 RtlSecondsSince1970ToTime( reply->write_time, (LARGE_INTEGER *)&info->ftLastWriteTime );
826 RtlSecondsSince1970ToTime( reply->access_time, (LARGE_INTEGER *)&info->ftLastAccessTime );
827 info->dwFileAttributes = reply->attr;
828 info->dwVolumeSerialNumber = reply->serial;
829 info->nFileSizeHigh = reply->size_high;
830 info->nFileSizeLow = reply->size_low;
831 info->nNumberOfLinks = reply->links;
832 info->nFileIndexHigh = reply->index_high;
833 info->nFileIndexLow = reply->index_low;
834 }
835 else
836 {
837 SetLastError(ERROR_NOT_SUPPORTED);
838 ret = 0;
839 }
840 }
841 }
842 SERVER_END_REQ;
843 return ret;
844 }
845
846
847 /**************************************************************************
848 * GetFileAttributesW (KERNEL32.@)
849 */
850 DWORD WINAPI GetFileAttributesW( LPCWSTR name )
851 {
852 DOS_FULL_NAME full_name;
853 BY_HANDLE_FILE_INFORMATION info;
854
855 if (name == NULL)
856 {
857 SetLastError( ERROR_INVALID_PARAMETER );
858 return -1;
859 }
860 if (!DOSFS_GetFullName( name, TRUE, &full_name) )
861 return -1;
862 if (!FILE_Stat( full_name.long_name, &info, NULL )) return -1;
863 return info.dwFileAttributes;
864 }
865
866
867 /**************************************************************************
868 * GetFileAttributesA (KERNEL32.@)
869 */
870 DWORD WINAPI GetFileAttributesA( LPCSTR name )
871 {
872 UNICODE_STRING nameW;
873 DWORD ret = (DWORD)-1;
874
875 if (!name)
876 {
877 SetLastError( ERROR_INVALID_PARAMETER );
878 return (DWORD)-1;
879 }
880
881 if (RtlCreateUnicodeStringFromAsciiz(&nameW, name))
882 {
883 ret = GetFileAttributesW(nameW.Buffer);
884 RtlFreeUnicodeString(&nameW);
885 }
886 else
887 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
888 return ret;
889 }
890
891
892 /**************************************************************************
893 * SetFileAttributesW (KERNEL32.@)
894 */
895 BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD attributes)
896 {
897 struct stat buf;
898 DOS_FULL_NAME full_name;
899
900 if (!lpFileName)
901 {
902 SetLastError( ERROR_INVALID_PARAMETER );
903 return FALSE;
904 }
905
906 TRACE("(%s,%lx)\n", debugstr_w(lpFileName), attributes);
907
908 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
909 return FALSE;
910
911 if(stat(full_name.long_name,&buf)==-1)
912 {
913 FILE_SetDosError();
914 return FALSE;
915 }
916 if (attributes & FILE_ATTRIBUTE_READONLY)
917 {
918 if(S_ISDIR(buf.st_mode))
919 /* FIXME */
920 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
921 else
922 buf.st_mode &= ~0222; /* octal!, clear write permission bits */
923 attributes &= ~FILE_ATTRIBUTE_READONLY;
924 }
925 else
926 {
927 /* add write permission */
928 buf.st_mode |= (0600 | ((buf.st_mode & 044) >> 1)) & (~FILE_umask);
929 }
930 if (attributes & FILE_ATTRIBUTE_DIRECTORY)
931 {
932 if (!S_ISDIR(buf.st_mode))
933 FIXME("SetFileAttributes expected the file %s to be a directory\n",
934 debugstr_w(lpFileName));
935 attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
936 }
937 attributes &= ~(FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
938 if (attributes)
939 FIXME("(%s):%lx attribute(s) not implemented.\n", debugstr_w(lpFileName), attributes);
940 if (-1==chmod(full_name.long_name,buf.st_mode))
941 {
942 if (GetDriveTypeW(lpFileName) == DRIVE_CDROM)
943 {
944 SetLastError( ERROR_ACCESS_DENIED );
945 return FALSE;
946 }
947
948 /*
949 * FIXME: We don't return FALSE here because of differences between
950 * Linux and Windows privileges. Under Linux only the owner of
951 * the file is allowed to change file attributes. Under Windows,
952 * applications expect that if you can write to a file, you can also
953 * change its attributes (see GENERIC_WRITE). We could try to be
954 * clever here but that would break multi-user installations where
955 * users share read-only DLLs. This is because some installers like
956 * to change attributes of already installed DLLs.
957 */
958 FIXME("Couldn't set file attributes for existing file \"%s\".\n"
959 "Check permissions or set VFAT \"quiet\" mount flag\n", full_name.long_name);
960 }
961 return TRUE;
962 }
963
964
965 /**************************************************************************
966 * SetFileAttributesA (KERNEL32.@)
967 */
968 BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD attributes)
969 {
970 UNICODE_STRING filenameW;
971 BOOL ret = FALSE;
972
973 if (!lpFileName)
974 {
975 SetLastError( ERROR_INVALID_PARAMETER );
976 return FALSE;
977 }
978
979 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, lpFileName))
980 {
981 ret = SetFileAttributesW(filenameW.Buffer, attributes);
982 RtlFreeUnicodeString(&filenameW);
983 }
984 else
985 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
986 return ret;
987 }
988
989
990 /***********************************************************************
991 * GetFileTime (KERNEL32.@)
992 */
993 BOOL WINAPI GetFileTime( HANDLE hFile, FILETIME *lpCreationTime,
994 FILETIME *lpLastAccessTime,
995 FILETIME *lpLastWriteTime )
996 {
997 BY_HANDLE_FILE_INFORMATION info;
998 if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
999 if (lpCreationTime) *lpCreationTime = info.ftCreationTime;
1000 if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
1001 if (lpLastWriteTime) *lpLastWriteTime = info.ftLastWriteTime;
1002 return TRUE;
1003 }
1004
1005
1006 /***********************************************************************
1007 * FILE_GetTempFileName : utility for GetTempFileName
1008 */
1009 static UINT FILE_GetTempFileName( LPCWSTR path, LPCWSTR prefix, UINT unique,
1010 LPWSTR buffer )
1011 {
1012 static UINT unique_temp;
1013 DOS_FULL_NAME full_name;
1014 int i;
1015 LPWSTR p;
1016 UINT num;
1017 char buf[20];
1018
1019 if ( !path || !prefix || !buffer )
1020 {
1021 SetLastError( ERROR_INVALID_PARAMETER );
1022 return 0;
1023 }
1024
1025 if (!unique_temp) unique_temp = time(NULL) & 0xffff;
1026 num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff);
1027
1028 strcpyW( buffer, path );
1029 p = buffer + strlenW(buffer);
1030
1031 /* add a \, if there isn't one and path is more than just the drive letter ... */
1032 if ( !((strlenW(buffer) == 2) && (buffer[1] == ':'))
1033 && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\';
1034
1035 for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
1036
1037 sprintf( buf, "%04x.tmp", num );
1038 MultiByteToWideChar(CP_ACP, 0, buf, -1, p, 20);
1039
1040 /* Now try to create it */
1041
1042 if (!unique)
1043 {
1044 do
1045 {
1046 HANDLE handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
1047 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
1048 if (handle != INVALID_HANDLE_VALUE)
1049 { /* We created it */
1050 TRACE("created %s\n", debugstr_w(buffer) );
1051 CloseHandle( handle );
1052 break;
1053 }
1054 if (GetLastError() != ERROR_FILE_EXISTS &&
1055 GetLastError() != ERROR_SHARING_VIOLATION)
1056 break; /* No need to go on */
1057 num++;
1058 sprintf( buf, "%04x.tmp", num );
1059 MultiByteToWideChar(CP_ACP, 0, buf, -1, p, 20);
1060 } while (num != (unique & 0xffff));
1061 }
1062
1063 /* Get the full path name */
1064
1065 if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
1066 {
1067 char *slash;
1068 /* Check if we have write access in the directory */
1069 if ((slash = strrchr( full_name.long_name, '/' ))) *slash = '\0';
1070 if (access( full_name.long_name, W_OK ) == -1)
1071 WARN("returns %s, which doesn't seem to be writeable.\n",
1072 debugstr_w(buffer) );
1073 }
1074 TRACE("returning %s\n", debugstr_w(buffer) );
1075 return unique ? unique : num;
1076 }
1077
1078
1079 /***********************************************************************
1080 * GetTempFileNameA (KERNEL32.@)
1081 */
1082 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
1083 LPSTR buffer)
1084 {
1085 UNICODE_STRING pathW, prefixW;
1086 WCHAR bufferW[MAX_PATH];
1087 UINT ret;
1088
1089 if ( !path || !prefix || !buffer )
1090 {
1091 SetLastError( ERROR_INVALID_PARAMETER );
1092 return 0;
1093 }
1094
1095 RtlCreateUnicodeStringFromAsciiz(&pathW, path);
1096 RtlCreateUnicodeStringFromAsciiz(&prefixW, prefix);
1097
1098 ret = GetTempFileNameW(pathW.Buffer, prefixW.Buffer, unique, bufferW);
1099 if (ret)
1100 WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
1101
1102 RtlFreeUnicodeString(&pathW);
1103 RtlFreeUnicodeString(&prefixW);
1104 return ret;
1105 }
1106
1107 /***********************************************************************
1108 * GetTempFileNameW (KERNEL32.@)
1109 */
1110 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
1111 LPWSTR buffer )
1112 {
1113 return FILE_GetTempFileName( path, prefix, unique, buffer );
1114 }
1115
1116
1117 /***********************************************************************
1118 * FILE_DoOpenFile
1119 *
1120 * Implementation of OpenFile16() and OpenFile32().
1121 */
1122 static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode, BOOL win32 )
1123 {
1124 HFILE hFileRet;
1125 HANDLE handle;
1126 FILETIME filetime;
1127 WORD filedatetime[2];
1128 DOS_FULL_NAME full_name;
1129 DWORD access, sharing;
1130 WCHAR *p;
1131 WCHAR buffer[MAX_PATH];
1132 LPWSTR nameW;
1133
1134 if (!ofs) return HFILE_ERROR;
1135
1136 TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",name,
1137 ((mode & 0x3 )==OF_READ)?"OF_READ":
1138 ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
1139 ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
1140 ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
1141 ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
1142 ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
1143 ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
1144 ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
1145 ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
1146 ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
1147 ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
1148 ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
1149 ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
1150 ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
1151 ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
1152 ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
1153 ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
1154 );
1155
1156
1157 ofs->cBytes = sizeof(OFSTRUCT);
1158 ofs->nErrCode = 0;
1159 if (mode & OF_REOPEN) name = ofs->szPathName;
1160
1161 if (!name) {
1162 ERR("called with `name' set to NULL ! Please debug.\n");
1163 return HFILE_ERROR;
1164 }
1165
1166 TRACE("%s %04x\n", name, mode );
1167
1168 /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
1169 Are there any cases where getting the path here is wrong?
1170 Uwe Bonnes 1997 Apr 2 */
1171 if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
1172 ofs->szPathName, NULL )) goto error;
1173 FILE_ConvertOFMode( mode, &access, &sharing );
1174
1175 /* OF_PARSE simply fills the structure */
1176
1177 if (mode & OF_PARSE)
1178 {
1179 ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
1180 != DRIVE_REMOVABLE);
1181 TRACE("(%s): OF_PARSE, res = '%s'\n",
1182 name, ofs->szPathName );
1183 return 0;
1184 }
1185
1186 /* OF_CREATE is completely different from all other options, so
1187 handle it first */
1188
1189 if (mode & OF_CREATE)
1190 {
1191 if ((handle = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
1192 sharing, NULL, CREATE_ALWAYS,
1193 FILE_ATTRIBUTE_NORMAL, 0 ))== INVALID_HANDLE_VALUE)
1194 goto error;
1195 goto success;
1196 }
1197
1198 MultiByteToWideChar(CP_ACP, 0, name, -1, buffer, MAX_PATH);
1199 nameW = buffer;
1200
1201 /* If OF_SEARCH is set, ignore the given path */
1202
1203 if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
1204 {
1205 /* First try the file name as is */
1206 if (DOSFS_GetFullName( nameW, TRUE, &full_name )) goto found;
1207 /* Now remove the path */
1208 if (nameW[0] && (nameW[1] == ':')) nameW += 2;
1209 if ((p = strrchrW( nameW, '\\' ))) nameW = p + 1;
1210 if ((p = strrchrW( nameW, '/' ))) nameW = p + 1;
1211 if (!nameW[0]) goto not_found;
1212 }
1213
1214 /* Now look for the file */
1215
1216 if (!DIR_SearchPath( NULL, nameW, NULL, &full_name, win32 )) goto not_found;
1217
1218 found:
1219 TRACE("found %s = %s\n",
1220 full_name.long_name, debugstr_w(full_name.short_name) );
1221 WideCharToMultiByte(CP_ACP, 0, full_name.short_name, -1,
1222 ofs->szPathName, sizeof(ofs->szPathName), NULL, NULL);
1223
1224 if (mode & OF_SHARE_EXCLUSIVE)
1225 /* Some InstallShield version uses OF_SHARE_EXCLUSIVE
1226 on the file <tempdir>/_ins0432._mp to determine how
1227 far installation has proceeded.
1228 _ins0432._mp is an executable and while running the
1229 application expects the open with OF_SHARE_ to fail*/
1230 /* Probable FIXME:
1231 As our loader closes the files after loading the executable,
1232 we can't find the running executable with FILE_InUse.
1233 The loader should keep the file open, as Windows does that, too.
1234 */
1235 {
1236 char *last = strrchr(full_name.long_name,'/');
1237 if (!last)
1238 last = full_name.long_name - 1;
1239 if (GetModuleHandle16(last+1))
1240 {
1241 TRACE("Denying shared open for %s\n",full_name.long_name);
1242 return HFILE_ERROR;
1243 }
1244 }
1245
1246 if (mode & OF_DELETE)
1247 {
1248 if (unlink( full_name.long_name ) == -1) goto not_found;
1249 TRACE("(%s): OF_DELETE return = OK\n", name);
1250 return 1;
1251 }
1252
1253 handle = FILE_CreateFile( full_name.long_name, access, sharing,
1254 NULL, OPEN_EXISTING, 0, 0,
1255 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY,
1256 GetDriveTypeW( full_name.short_name ) );
1257 if (!handle) goto not_found;
1258
1259 GetFileTime( handle, NULL, NULL, &filetime );
1260 FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
1261 if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
1262 {
1263 if (ofs->Reserved1 != filedatetime[0] || ofs->Reserved2 != filedatetime[1] )
1264 {
1265 CloseHandle( handle );
1266 WARN("(%s): OF_VERIFY failed\n", name );
1267 /* FIXME: what error here? */
1268 SetLastError( ERROR_FILE_NOT_FOUND );
1269 goto error;
1270 }
1271 }
1272 ofs->Reserved1 = filedatetime[0];
1273 ofs->Reserved2 = filedatetime[1];
1274
1275 success: /* We get here if the open was successful */
1276 TRACE("(%s): OK, return = %p\n", name, handle );
1277 if (win32)
1278 {
1279 hFileRet = (HFILE)handle;
1280 if (mode & OF_EXIST) /* Return the handle, but close it first */
1281 CloseHandle( handle );
1282 }
1283 else
1284 {
1285 hFileRet = Win32HandleToDosFileHandle( handle );
1286 if (hFileRet == HFILE_ERROR16) goto error;
1287 if (mode & OF_EXIST) /* Return the handle, but close it first */
1288 _lclose16( hFileRet );
1289 }
1290 return hFileRet;
1291
1292 not_found: /* We get here if the file does not exist */
1293 WARN("'%s' not found or sharing violation\n", name );
1294 SetLastError( ERROR_FILE_NOT_FOUND );
1295 /* fall through */
1296
1297 error: /* We get here if there was an error opening the file */
1298 ofs->nErrCode = GetLastError();
1299 WARN("(%s): return = HFILE_ERROR error= %d\n",
1300 name,ofs->nErrCode );
1301 return HFILE_ERROR;
1302 }
1303
1304
1305 /***********************************************************************
1306 * OpenFile (KERNEL.74)
1307 * OpenFileEx (KERNEL.360)
1308 */
1309 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
1310 {
1311 return FILE_DoOpenFile( name, ofs, mode, FALSE );
1312 }
1313
1314
1315 /***********************************************************************
1316 * OpenFile (KERNEL32.@)
1317 */
1318 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
1319 {
1320 return FILE_DoOpenFile( name, ofs, mode, TRUE );
1321 }
1322
1323
1324 /***********************************************************************
1325 * FILE_InitProcessDosHandles
1326 *
1327 * Allocates the default DOS handles for a process. Called either by
1328 * Win32HandleToDosFileHandle below or by the DOSVM stuff.
1329 */
1330 static void FILE_InitProcessDosHandles( void )
1331 {
1332 HANDLE cp = GetCurrentProcess();
1333 DuplicateHandle(cp, GetStdHandle(STD_INPUT_HANDLE), cp, &dos_handles[0],
1334 0, TRUE, DUPLICATE_SAME_ACCESS);
1335 DuplicateHandle(cp, GetStdHandle(STD_OUTPUT_HANDLE), cp, &dos_handles[1],
1336 0, TRUE, DUPLICATE_SAME_ACCESS);
1337 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[2],
1338 0, TRUE, DUPLICATE_SAME_ACCESS);
1339 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[3],
1340 0, TRUE, DUPLICATE_SAME_ACCESS);
1341 DuplicateHandle(cp, GetStdHandle(STD_ERROR_HANDLE), cp, &dos_handles[4],
1342 0, TRUE, DUPLICATE_SAME_ACCESS);
1343 }
1344
1345 /***********************************************************************
1346 * Win32HandleToDosFileHandle (KERNEL32.21)
1347 *
1348 * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
1349 * longer valid after this function (even on failure).
1350 *
1351 * Note: this is not exactly right, since on Win95 the Win32 handles
1352 * are on top of DOS handles and we do it the other way
1353 * around. Should be good enough though.
1354 */
1355 HFILE WINAPI Win32HandleToDosFileHandle( HANDLE handle )
1356 {
1357 int i;
1358
1359 if (!handle || (handle == INVALID_HANDLE_VALUE))
1360 return HFILE_ERROR;
1361
1362 for (i = 5; i < DOS_TABLE_SIZE; i++)
1363 if (!dos_handles[i])
1364 {
1365 dos_handles[i] = handle;
1366 TRACE("Got %d for h32 %p\n", i, handle );
1367 return (HFILE)i;
1368 }
1369 CloseHandle( handle );
1370 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1371 return HFILE_ERROR;
1372 }
1373
1374
1375 /***********************************************************************
1376 * DosFileHandleToWin32Handle (KERNEL32.20)
1377 *
1378 * Return the Win32 handle for a DOS handle.
1379 *
1380 * Note: this is not exactly right, since on Win95 the Win32 handles
1381 * are on top of DOS handles and we do it the other way
1382 * around. Should be good enough though.
1383 */
1384 HANDLE WINAPI DosFileHandleToWin32Handle( HFILE handle )
1385 {
1386 HFILE16 hfile = (HFILE16)handle;
1387 if (hfile < 5 && !dos_handles[hfile]) FILE_InitProcessDosHandles();
1388 if ((hfile >= DOS_TABLE_SIZE) || !dos_handles[hfile])
1389 {
1390 SetLastError( ERROR_INVALID_HANDLE );
1391 return INVALID_HANDLE_VALUE;
1392 }
1393 return dos_handles[hfile];
1394 }
1395
1396
1397 /***********************************************************************
1398 * DisposeLZ32Handle (KERNEL32.22)
1399 *
1400 * Note: this is not entirely correct, we should only close the
1401 * 32-bit handle and not the 16-bit one, but we cannot do
1402 * this because of the way our DOS handles are implemented.
1403 * It shouldn't break anything though.
1404 */
1405 void WINAPI DisposeLZ32Handle( HANDLE handle )
1406 {
1407 int i;
1408
1409 if (!handle || (handle == INVALID_HANDLE_VALUE)) return;
1410
1411 for (i = 5; i < DOS_TABLE_SIZE; i++)
1412 if (dos_handles[i] == handle)
1413 {
1414 dos_handles[i] = 0;
1415 CloseHandle( handle );
1416 break;
1417 }
1418 }
1419
1420
1421 /***********************************************************************
1422 * FILE_Dup2
1423 *
1424 * dup2() function for DOS handles.
1425 */
1426 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1427 {
1428 HANDLE new_handle;
1429
1430 if (hFile1 < 5 && !dos_handles[hFile1]) FILE_InitProcessDosHandles();
1431
1432 if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) || !dos_handles[hFile1])
1433 {
1434 SetLastError( ERROR_INVALID_HANDLE );
1435 return HFILE_ERROR16;
1436 }
1437 if (!DuplicateHandle( GetCurrentProcess(), dos_handles[hFile1],
1438 GetCurrentProcess(), &new_handle,
1439 0, FALSE, DUPLICATE_SAME_ACCESS ))
1440 return HFILE_ERROR16;
1441 if (dos_handles[hFile2]) CloseHandle( dos_handles[hFile2] );
1442 dos_handles[hFile2] = new_handle;
1443 return hFile2;
1444 }
1445
1446
1447 /***********************************************************************
1448 * _lclose (KERNEL.81)
1449 */
1450 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1451 {
1452 if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
1453 {
1454 SetLastError( ERROR_INVALID_HANDLE );
1455 return HFILE_ERROR16;
1456 }
1457 TRACE("%d (handle32=%p)\n", hFile, dos_handles[hFile] );
1458 CloseHandle( dos_handles[hFile] );
1459 dos_handles[hFile] = 0;
1460 return 0;
1461 }
1462
1463
1464 /******************************************************************
1465 * FILE_ReadWriteApc (internal)
1466 *
1467 *
1468 */
1469 static void WINAPI FILE_ReadWriteApc(void* apc_user, PIO_STATUS_BLOCK io_status, ULONG len)
1470 {
1471 LPOVERLAPPED_COMPLETION_ROUTINE cr = (LPOVERLAPPED_COMPLETION_ROUTINE)apc_user;
1472
1473 cr(RtlNtStatusToDosError(io_status->u.Status), len, (LPOVERLAPPED)io_status);
1474 }
1475
1476 /***********************************************************************
1477 * ReadFileEx (KERNEL32.@)
1478 */
1479 BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1480 LPOVERLAPPED overlapped,
1481 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1482 {
1483 LARGE_INTEGER offset;
1484 NTSTATUS status;
1485 PIO_STATUS_BLOCK io_status;
1486
1487 if (!overlapped)
1488 {
1489 SetLastError(ERROR_INVALID_PARAMETER);
1490 return FALSE;
1491 }
1492
1493 offset.s.LowPart = overlapped->Offset;
1494 offset.s.HighPart = overlapped->OffsetHigh;
1495 io_status = (PIO_STATUS_BLOCK)overlapped;
1496 io_status->u.Status = STATUS_PENDING;
1497
1498 status = NtReadFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
1499 io_status, buffer, bytesToRead, &offset, NULL);
1500
1501 if (status)
1502 {
1503 SetLastError( RtlNtStatusToDosError(status) );
1504 return FALSE;
1505 }
1506 return TRUE;
1507 }
1508
1509 /***********************************************************************
1510 * ReadFile (KERNEL32.@)
1511 */
1512 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1513 LPDWORD bytesRead, LPOVERLAPPED overlapped )
1514 {
1515 LARGE_INTEGER offset;
1516 PLARGE_INTEGER poffset = NULL;
1517 IO_STATUS_BLOCK iosb;
1518 PIO_STATUS_BLOCK io_status = &iosb;
1519 HANDLE hEvent = 0;
1520 NTSTATUS status;
1521
1522 TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToRead,
1523 bytesRead, overlapped );
1524
1525 if (bytesRead) *bytesRead = 0; /* Do this before anything else */
1526 if (!bytesToRead) return TRUE;
1527
1528 if (IsBadReadPtr(buffer, bytesToRead))
1529 {
1530 SetLastError(ERROR_WRITE_FAULT); /* FIXME */
1531 return FALSE;
1532 }
1533 if (is_console_handle(hFile))
1534 return FILE_ReadConsole(hFile, buffer, bytesToRead, bytesRead, NULL);
1535
1536 if (overlapped != NULL)
1537 {
1538 offset.s.LowPart = overlapped->Offset;
1539 offset.s.HighPart = overlapped->OffsetHigh;
1540 poffset = &offset;
1541 hEvent = overlapped->hEvent;
1542 io_status = (PIO_STATUS_BLOCK)overlapped;
1543 }
1544 io_status->u.Status = STATUS_PENDING;
1545 io_status->Information = 0;
1546
1547 status = NtReadFile(hFile, hEvent, NULL, NULL, io_status, buffer, bytesToRead, poffset, NULL);
1548
1549 if (status != STATUS_PENDING && bytesRead)
1550 *bytesRead = io_status->Information;
1551
1552 if (status && status != STATUS_END_OF_FILE)
1553 {
1554 SetLastError( RtlNtStatusToDosError(status) );
1555 return FALSE;
1556 }
1557 return TRUE;
1558 }
1559
1560
1561 /***********************************************************************
1562 * WriteFileEx (KERNEL32.@)
1563 */
1564 BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1565 LPOVERLAPPED overlapped,
1566 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1567 {
1568 LARGE_INTEGER offset;
1569 NTSTATUS status;
1570 PIO_STATUS_BLOCK io_status;
1571
1572 TRACE("%p %p %ld %p %p\n",
1573 hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine);
1574
1575 if (overlapped == NULL)
1576 {
1577 SetLastError(ERROR_INVALID_PARAMETER);
1578 return FALSE;
1579 }
1580 offset.s.LowPart = overlapped->Offset;
1581 offset.s.HighPart = overlapped->OffsetHigh;
1582
1583 io_status = (PIO_STATUS_BLOCK)overlapped;
1584 io_status->u.Status = STATUS_PENDING;
1585
1586 status = NtWriteFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
1587 io_status, buffer, bytesToWrite, &offset, NULL);
1588
1589 if (status) SetLastError( RtlNtStatusToDosError(status) );
1590 return !status;
1591 }
1592
1593 /***********************************************************************
1594 * WriteFile (KERNEL32.@)
1595 */
1596 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1597 LPDWORD bytesWritten, LPOVERLAPPED overlapped )
1598 {
1599 HANDLE hEvent = NULL;
1600 LARGE_INTEGER offset;
1601 PLARGE_INTEGER poffset = NULL;
1602 NTSTATUS status;
1603 IO_STATUS_BLOCK iosb;
1604 PIO_STATUS_BLOCK piosb = &iosb;
1605
1606 TRACE("%p %p %ld %p %p\n",
1607 hFile, buffer, bytesToWrite, bytesWritten, overlapped );
1608
1609 if (is_console_handle(hFile))
1610 return FILE_WriteConsole(hFile, buffer, bytesToWrite, bytesWritten, NULL);
1611
1612 if (IsBadReadPtr(buffer, bytesToWrite))
1613 {
1614 SetLastError(ERROR_READ_FAULT); /* FIXME */
1615 return FALSE;
1616 }
1617
1618 if (overlapped)
1619 {
1620 offset.s.LowPart = overlapped->Offset;
1621 offset.s.HighPart = overlapped->OffsetHigh;
1622 poffset = &offset;
1623 hEvent = overlapped->hEvent;
1624 piosb = (PIO_STATUS_BLOCK)overlapped;
1625 }
1626 piosb->u.Status = STATUS_PENDING;
1627 piosb->Information = 0;
1628
1629 status = NtWriteFile(hFile, hEvent, NULL, NULL, piosb,
1630 buffer, bytesToWrite, poffset, NULL);
1631 if (status)
1632 {
1633 SetLastError( RtlNtStatusToDosError(status) );
1634 return FALSE;
1635 }
1636 if (bytesWritten) *bytesWritten = piosb->Information;
1637
1638 return TRUE;
1639 }
1640
1641
1642 /***********************************************************************
1643 * SetFilePointer (KERNEL32.@)
1644 */
1645 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
1646 DWORD method )
1647 {
1648 DWORD ret = INVALID_SET_FILE_POINTER;
1649
1650 TRACE("handle %p offset %ld high %ld origin %ld\n",
1651 hFile, distance, highword?*highword:0, method );
1652
1653 SERVER_START_REQ( set_file_pointer )
1654 {
1655 req->handle = hFile;
1656 req->low = distance;
1657 req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
1658 /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
1659 req->whence = method;
1660 SetLastError( 0 );
1661 if (!wine_server_call_err( req ))
1662 {
1663 ret = reply->new_low;
1664 if (highword) *highword = reply->new_high;
1665 }
1666 }
1667 SERVER_END_REQ;
1668 return ret;
1669 }
1670
1671
1672 /*************************************************************************
1673 * SetHandleCount (KERNEL32.@)
1674 */
1675 UINT WINAPI SetHandleCount( UINT count )
1676 {
1677 return min( 256, count );
1678 }
1679
1680
1681 /**************************************************************************
1682 * SetEndOfFile (KERNEL32.@)
1683 */
1684 BOOL WINAPI SetEndOfFile( HANDLE hFile )
1685 {
1686 BOOL ret;
1687 SERVER_START_REQ( truncate_file )
1688 {
1689 req->handle = hFile;
1690 ret = !wine_server_call_err( req );
1691 }
1692 SERVER_END_REQ;
1693 return ret;
1694 }
1695
1696
1697 /***********************************************************************
1698 * DeleteFileW (KERNEL32.@)
1699 */
1700 BOOL WINAPI DeleteFileW( LPCWSTR path )
1701 {
1702 DOS_FULL_NAME full_name;
1703 HANDLE hFile;
1704
1705 TRACE("%s\n", debugstr_w(path) );
1706 if (!path || !*path)
1707 {
1708 SetLastError(ERROR_PATH_NOT_FOUND);
1709 return FALSE;
1710 }
1711 if (DOSFS_GetDevice( path ))
1712 {
1713 WARN("cannot remove DOS device %s!\n", debugstr_w(path));
1714 SetLastError( ERROR_FILE_NOT_FOUND );
1715 return FALSE;
1716 }
1717
1718 if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
1719
1720 /* check if we are allowed to delete the source */
1721 hFile = FILE_CreateFile( full_name.long_name, GENERIC_READ|GENERIC_WRITE, 0,
1722 NULL, OPEN_EXISTING, 0, 0, TRUE,
1723 GetDriveTypeW( full_name.short_name ) );
1724 if (!hFile) return FALSE;
1725
1726 if (unlink( full_name.long_name ) == -1)
1727 {
1728 FILE_SetDosError();
1729 CloseHandle(hFile);
1730 return FALSE;
1731 }
1732 CloseHandle(hFile);
1733 return TRUE;
1734 }
1735
1736
1737 /***********************************************************************
1738 * DeleteFileA (KERNEL32.@)
1739 */
1740 BOOL WINAPI DeleteFileA( LPCSTR path )
1741 {
1742 UNICODE_STRING pathW;
1743 BOOL ret = FALSE;
1744
1745 if (!path)
1746 {
1747 SetLastError(ERROR_INVALID_PARAMETER);
1748 return FALSE;
1749 }
1750
1751 if (RtlCreateUnicodeStringFromAsciiz(&pathW, path))
1752 {
1753 ret = DeleteFileW(pathW.Buffer);
1754 RtlFreeUnicodeString(&pathW);
1755 }
1756 else
1757 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1758 return ret;
1759 }
1760
1761
1762 /***********************************************************************
1763 * GetFileType (KERNEL32.@)
1764 */
1765 DWORD WINAPI GetFileType( HANDLE hFile )
1766 {
1767 DWORD ret = FILE_TYPE_UNKNOWN;
1768
1769 if (is_console_handle( hFile ))
1770 return FILE_TYPE_CHAR;
1771
1772 SERVER_START_REQ( get_file_info )
1773 {
1774 req->handle = hFile;
1775 if (!wine_server_call_err( req )) ret = reply->type;
1776 }
1777 SERVER_END_REQ;
1778 return ret;
1779 }
1780
1781
1782 /* check if a file name is for an executable file (.exe or .com) */
1783 inline static BOOL is_executable( const char *name )
1784 {
1785 int len = strlen(name);
1786
1787 if (len < 4) return FALSE;
1788 return (!strcasecmp( name + len - 4, ".exe" ) ||
1789 !strcasecmp( name + len - 4, ".com" ));
1790 }
1791
1792
1793 /***********************************************************************
1794 * FILE_AddBootRenameEntry
1795 *
1796 * Adds an entry to the registry that is loaded when windows boots and
1797 * checks if there are some files to be removed or renamed/moved.
1798 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
1799 * non-NULL then the file is moved, otherwise it is deleted. The
1800 * entry of the registrykey is always appended with two zero
1801 * terminated strings. If <fn2> is NULL then the second entry is
1802 * simply a single 0-byte. Otherwise the second filename goes
1803 * there. The entries are prepended with \??\ before the path and the
1804 * second filename gets also a '!' as the first character if
1805 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
1806 * 0-byte follows to indicate the end of the strings.
1807 * i.e.:
1808 * \??\D:\test\file1[0]
1809 * !\??\D:\test\file1_renamed[0]
1810 * \??\D:\Test|delete[0]
1811 * [0] <- file is to be deleted, second string empty
1812 * \??\D:\test\file2[0]
1813 * !\??\D:\test\file2_renamed[0]
1814 * [0] <- indicates end of strings
1815 *
1816 * or:
1817 * \??\D:\test\file1[0]
1818 * !\??\D:\test\file1_renamed[0]
1819 * \??\D:\Test|delete[0]
1820 * [0] <- file is to be deleted, second string empty
1821 * [0] <- indicates end of strings
1822 *
1823 */
1824 static BOOL FILE_AddBootRenameEntry( LPCWSTR fn1, LPCWSTR fn2, DWORD flags )
1825 {
1826 static const WCHAR PreString[] = {'\\','?','?','\\',0};
1827 static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
1828 'F','i','l','e','R','e','n','a','m','e',
1829 'O','p','e','r','a','t','i','o','n','s',0};
1830 static const WCHAR SessionW[] = {'M','a','c','h','i','n','e','\\',
1831 'S','y','s','t','e','m','\\',
1832 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1833 'C','o','n','t','r','o','l','\\',
1834 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
1835 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
1836
1837 OBJECT_ATTRIBUTES attr;
1838 UNICODE_STRING nameW;
1839 KEY_VALUE_PARTIAL_INFORMATION *info;
1840 BOOL rc = FALSE;
1841 HKEY Reboot = 0;
1842 DWORD len0, len1, len2;
1843 DWORD DataSize = 0;
1844 BYTE *Buffer = NULL;
1845 WCHAR *p;
1846
1847 attr.Length = sizeof(attr);
1848 attr.RootDirectory = 0;
1849 attr.ObjectName = &nameW;
1850 attr.Attributes = 0;
1851 attr.SecurityDescriptor = NULL;
1852 attr.SecurityQualityOfService = NULL;
1853 RtlInitUnicodeString( &nameW, SessionW );
1854
1855 if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
1856 {
1857 WARN("Error creating key for reboot managment [%s]\n",
1858 "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
1859 return FALSE;
1860 }
1861
1862 len0 = strlenW(PreString);
1863 len1 = strlenW(fn1) + len0 + 1;
1864 if (fn2)
1865 {
1866 len2 = strlenW(fn2) + len0 + 1;
1867 if (flags & MOVEFILE_REPLACE_EXISTING) len2++; /* Plus 1 because of the leading '!' */
1868 }
1869 else len2 = 1; /* minimum is the 0 characters for the empty second string */
1870
1871 /* convert characters to bytes */
1872 len0 *= sizeof(WCHAR);
1873 len1 *= sizeof(WCHAR);
1874 len2 *= sizeof(WCHAR);
1875
1876 RtlInitUnicodeString( &nameW, ValueName );
1877
1878 /* First we check if the key exists and if so how many bytes it already contains. */
1879 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
1880 NULL, 0, &DataSize ) == STATUS_BUFFER_OVERFLOW)
1881 {
1882 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
1883 goto Quit;
1884 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
1885 Buffer, DataSize, &DataSize )) goto Quit;
1886 info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
1887 if (info->Type != REG_MULTI_SZ) goto Quit;
1888 if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
1889 }
1890 else
1891 {
1892 DataSize = info_size;
1893 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
1894 goto Quit;
1895 }
1896
1897 p = (WCHAR *)(Buffer + DataSize);
1898 strcpyW( p, PreString );
1899 strcatW( p, fn1 );
1900 DataSize += len1;
1901 if (fn2)
1902 {
1903 p = (WCHAR *)(Buffer + DataSize);
1904 if (flags & MOVEFILE_REPLACE_EXISTING)
1905 *p++ = '!';
1906 strcpyW( p, PreString );
1907 strcatW( p, fn2 );
1908 DataSize += len2;
1909 }
1910 else
1911 {
1912 p = (WCHAR *)(Buffer + DataSize);
1913 *p = 0;
1914 DataSize += sizeof(WCHAR);
1915 }
1916
1917 /* add final null */
1918 p = (WCHAR *)(Buffer + DataSize);
1919 *p = 0;
1920 DataSize += sizeof(WCHAR);
1921
1922 rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
1923
1924 Quit:
1925 if (Reboot) NtClose(Reboot);
1926 if (Buffer) HeapFree( GetProcessHeap(), 0, Buffer );
1927 return(rc);
1928 }
1929
1930
1931 /**************************************************************************
1932 * MoveFileExW (KERNEL32.@)
1933 */
1934 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
1935 {
1936 DOS_FULL_NAME full_name1, full_name2;
1937 HANDLE hFile;
1938 DWORD attr = INVALID_FILE_ATTRIBUTES;
1939
1940 TRACE("(%s,%s,%04lx)\n", debugstr_w(fn1), debugstr_w(fn2), flag);
1941
1942 /* FIXME: <Gerhard W. Gruber>sparhawk@gmx.at
1943 In case of W9x and lesser this function should return 120 (ERROR_CALL_NOT_IMPLEMENTED)
1944 to be really compatible. Most programs wont have any problems though. In case
1945 you encounter one, this is what you should return here. I don't know what's up
1946 with NT 3.5. Is this function available there or not?
1947 Does anybody really care about 3.5? :)
1948 */
1949
1950 /* Filename1 has to be always set to a valid path. Filename2 may be NULL
1951 if the source file has to be deleted.
1952 */
1953 if (!fn1) {
1954 SetLastError(ERROR_INVALID_PARAMETER);
1955 return FALSE;
1956 }
1957
1958 /* This function has to be run through in order to process the name properly.
1959 If the BOOTDELAY flag is set, the file doesn't need to exist though. At least
1960 that is the behaviour on NT 4.0. The operation accepts the filenames as
1961 they are given but it can't reply with a reasonable returncode. Success
1962 means in that case success for entering the values into the registry.
1963 */
1964 if(!DOSFS_GetFullName( fn1, TRUE, &full_name1 ))
1965 {
1966 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
1967 return FALSE;
1968 }
1969
1970 if (fn2) /* !fn2 means delete fn1 */
1971 {
1972 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
1973 {
1974 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
1975 {
1976 /* target exists, check if we may overwrite */
1977 if (!(flag & MOVEFILE_REPLACE_EXISTING))
1978 {
1979 SetLastError( ERROR_FILE_EXISTS );
1980 return FALSE;
1981 }
1982 }
1983 }
1984 else
1985 {
1986 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 ))
1987 {
1988 if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
1989 return FALSE;
1990 }
1991 }
1992
1993 /* Source name and target path are valid */
1994
1995 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1996 {
1997 return FILE_AddBootRenameEntry( fn1, fn2, flag );
1998 }
1999
2000 attr = GetFileAttributesW( fn1 );
2001 if ( attr == INVALID_FILE_ATTRIBUTES ) return FALSE;
2002
2003 /* check if we are allowed to rename the source */
2004 hFile = FILE_CreateFile( full_name1.long_name, 0, 0,
2005 NULL, OPEN_EXISTING, 0, 0, TRUE,
2006 GetDriveTypeW( full_name1.short_name ) );
2007 if (!hFile)
2008 {
2009 if (GetLastError() != ERROR_ACCESS_DENIED) return FALSE;
2010 if ( !(attr & FILE_ATTRIBUTE_DIRECTORY) ) return FALSE;
2011 /* if it's a directory we can continue */
2012 }
2013 else CloseHandle(hFile);
2014
2015 /* check, if we are allowed to delete the destination,
2016 ** (but the file not being there is fine) */
2017 hFile = FILE_CreateFile( full_name2.long_name, GENERIC_READ|GENERIC_WRITE, 0,
2018 NULL, OPEN_EXISTING, 0, 0, TRUE,
2019 GetDriveTypeW( full_name2.short_name ) );
2020 if(!hFile && GetLastError() != ERROR_FILE_NOT_FOUND) return FALSE;
2021 CloseHandle(hFile);
2022
2023 if (full_name1.drive != full_name2.drive)
2024 {
2025 if (!(flag & MOVEFILE_COPY_ALLOWED))
2026 {
2027 SetLastError( ERROR_NOT_SAME_DEVICE );
2028 return FALSE;
2029 }
2030 else if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2031 {
2032 /* Strange, but that's what Windows returns */
2033 SetLastError ( ERROR_ACCESS_DENIED );
2034 return FALSE;
2035 }
2036 }
2037 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
2038 /* Try copy/delete unless it's a directory. */
2039 /* FIXME: This does not handle the (unlikely) case that the two locations
2040 are on the same Wine drive, but on different Unix file systems. */
2041 {
2042 if ( attr & FILE_ATTRIBUTE_DIRECTORY )
2043 {
2044 FILE_SetDosError();
2045 return FALSE;
2046 }
2047 else
2048 {
2049 if ( ! CopyFileW( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) ))
2050 return FALSE;
2051 if ( ! DeleteFileW ( fn1 ) )
2052 return FALSE;
2053 }
2054 }
2055 if (is_executable( full_name1.long_name ) != is_executable( full_name2.long_name ))
2056 {
2057 struct stat fstat;
2058 if (stat( full_name2.long_name, &fstat ) != -1)
2059 {
2060 if (is_executable( full_name2.long_name ))
2061 /* set executable bit where read bit is set */
2062 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
2063 else
2064 fstat.st_mode &= ~0111;
2065 chmod( full_name2.long_name, fstat.st_mode );
2066 }
2067 }
2068 return TRUE;
2069 }
2070 else /* fn2 == NULL means delete source */
2071 {
2072 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
2073 {
2074 if (flag & MOVEFILE_COPY_ALLOWED) {
2075 WARN("Illegal flag\n");
2076 SetLastError( ERROR_GEN_FAILURE );
2077 return FALSE;
2078 }
2079
2080 return FILE_AddBootRenameEntry( fn1, NULL, flag );
2081 }
2082
2083 if (unlink( full_name1.long_name ) == -1)
2084 {
2085 FILE_SetDosError();
2086 return FALSE;
2087 }
2088 return TRUE; /* successfully deleted */
2089 }
2090 }
2091
2092 /**************************************************************************
2093 * MoveFileExA (KERNEL32.@)
2094 */
2095 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
2096 {
2097 UNICODE_STRING fn1W, fn2W;
2098 BOOL ret;
2099
2100 if (!fn1)
2101 {
2102 SetLastError(ERROR_INVALID_PARAMETER);
2103 return FALSE;
2104 }
2105
2106 RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
2107 if (fn2) RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
2108 else fn2W.Buffer = NULL;
2109
2110 ret = MoveFileExW( fn1W.Buffer, fn2W.Buffer, flag );
2111
2112 RtlFreeUnicodeString(&fn1W);
2113 RtlFreeUnicodeString(&fn2W);
2114 return ret;
2115 }
2116
2117
2118 /**************************************************************************
2119 * MoveFileW (KERNEL32.@)
2120 *
2121 * Move file or directory
2122 */
2123 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
2124 {
2125 return MoveFileExW( fn1, fn2, MOVEFILE_COPY_ALLOWED );
2126 }
2127
2128
2129 /**************************************************************************
2130 * MoveFileA (KERNEL32.@)
2131 */
2132 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
2133 {
2134 return MoveFileExA( fn1, fn2, MOVEFILE_COPY_ALLOWED );
2135 }
2136
2137
2138 /**************************************************************************
2139 * CopyFileW (KERNEL32.@)
2140 */
2141 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
2142 {
2143 HANDLE h1, h2;
2144 BY_HANDLE_FILE_INFORMATION info;
2145 DWORD count;
2146 BOOL ret = FALSE;
2147 char buffer[2048];
2148
2149 if (!source || !dest)
2150 {
2151 SetLastError(ERROR_INVALID_PARAMETER);
2152 return FALSE;
2153 }
2154
2155 TRACE("%s -> %s\n", debugstr_w(source), debugstr_w(dest));
2156
2157 if ((h1 = CreateFileW(source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
2158 NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
2159 {
2160 WARN("Unable to open source %s\n", debugstr_w(source));
2161 return FALSE;
2162 }
2163
2164 if (!GetFileInformationByHandle( h1, &info ))
2165 {
2166 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
2167 CloseHandle( h1 );
2168 return FALSE;
2169 }
2170
2171 if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2172 fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
2173 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
2174 {
2175 WARN("Unable to open dest %s\n", debugstr_w(dest));
2176 CloseHandle( h1 );
2177 return FALSE;
2178 }
2179
2180 while (ReadFile( h1, buffer, sizeof(buffer), &count, NULL ) && count)
2181 {
2182 char *p = buffer;
2183 while (count != 0)
2184 {
2185 DWORD res;
2186 if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
2187 p += res;
2188 count -= res;
2189 }
2190 }
2191 ret = TRUE;
2192 done:
2193 CloseHandle( h1 );
2194 CloseHandle( h2 );
2195 return ret;
2196 }
2197
2198
2199 /**************************************************************************
2200 * CopyFileA (KERNEL32.@)
2201 */
2202 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
2203 {
2204 UNICODE_STRING sourceW, destW;
2205 BOOL ret;
2206
2207 if (!source || !dest)
2208 {
2209 SetLastError(ERROR_INVALID_PARAMETER);
2210 return FALSE;
2211 }
2212
2213 RtlCreateUnicodeStringFromAsciiz(&sourceW, source);
2214 RtlCreateUnicodeStringFromAsciiz(&destW, dest);
2215
2216 ret = CopyFileW(sourceW.Buffer, destW.Buffer, fail_if_exists);
2217
2218 RtlFreeUnicodeString(&sourceW);
2219 RtlFreeUnicodeString(&destW);
2220 return ret;
2221 }
2222
2223
2224 /**************************************************************************
2225 * CopyFileExW (KERNEL32.@)
2226 *
2227 * This implementation ignores most of the extra parameters passed-in into
2228 * the "ex" version of the method and calls the CopyFile method.
2229 * It will have to be fixed eventually.
2230 */
2231 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename, LPCWSTR destFilename,
2232 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2233 LPBOOL cancelFlagPointer, DWORD copyFlags)
2234 {
2235 /*
2236 * Interpret the only flag that CopyFile can interpret.
2237 */
2238 return CopyFileW(sourceFilename, destFilename, (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0);
2239 }
2240
2241
2242 /**************************************************************************
2243 * CopyFileExA (KERNEL32.@)
2244 */
2245 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
2246 LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
2247 LPBOOL cancelFlagPointer, DWORD copyFlags)
2248 {
2249 UNICODE_STRING sourceW, destW;
2250 BOOL ret;
2251
2252 if (!sourceFilename || !destFilename)
2253 {
2254 SetLastError(ERROR_INVALID_PARAMETER);
2255 return FALSE;
2256 }
2257
2258 RtlCreateUnicodeStringFromAsciiz(&sourceW, sourceFilename);
2259 RtlCreateUnicodeStringFromAsciiz(&destW, destFilename);
2260
2261 ret = CopyFileExW(sourceW.Buffer, destW.Buffer, progressRoutine, appData,
2262 cancelFlagPointer, copyFlags);
2263
2264 RtlFreeUnicodeString(&sourceW);
2265 RtlFreeUnicodeString(&destW);
2266 return ret;
2267 }
2268
2269
2270 /***********************************************************************
2271 * SetFileTime (KERNEL32.@)
2272 */
2273 BOOL WINAPI SetFileTime( HANDLE hFile,
2274 const FILETIME *lpCreationTime,
2275 const FILETIME *lpLastAccessTime,
2276 const FILETIME *lpLastWriteTime )
2277 {
2278 BOOL ret;
2279 SERVER_START_REQ( set_file_time )
2280 {
2281 req->handle = hFile;
2282 if (lpLastAccessTime)
2283 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastAccessTime, (DWORD *)&req->access_time );
2284 else
2285 req->access_time = 0; /* FIXME */
2286 if (lpLastWriteTime)
2287 RtlTimeToSecondsSince1970( (PLARGE_INTEGER) lpLastWriteTime, (DWORD *)&req->write_time );
2288 else
2289 req->write_time = 0; /* FIXME */
2290 ret = !wine_server_call_err( req );
2291 }
2292 SERVER_END_REQ;
2293 return ret;
2294 }
2295
2296
2297 /**************************************************************************
2298 * GetFileAttributesExW (KERNEL32.@)
2299 */
2300 BOOL WINAPI GetFileAttributesExW(
2301 LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2302 LPVOID lpFileInformation)
2303 {
2304 DOS_FULL_NAME full_name;
2305 BY_HANDLE_FILE_INFORMATION info;
2306
2307 if (!lpFileName || !lpFileInformation)
2308 {
2309 SetLastError(ERROR_INVALID_PARAMETER);
2310 return FALSE;
2311 }
2312
2313 if (fInfoLevelId == GetFileExInfoStandard) {
2314 LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
2315 (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
2316 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
2317 if (!FILE_Stat( full_name.long_name, &info, NULL )) return FALSE;
2318
2319 lpFad->dwFileAttributes = info.dwFileAttributes;
2320 lpFad->ftCreationTime = info.ftCreationTime;
2321 lpFad->ftLastAccessTime = info.ftLastAccessTime;
2322 lpFad->ftLastWriteTime = info.ftLastWriteTime;
2323 lpFad->nFileSizeHigh = info.nFileSizeHigh;
2324 lpFad->nFileSizeLow = info.nFileSizeLow;
2325 }
2326 else {
2327 FIXME("invalid info level %d!\n", fInfoLevelId);
2328 return FALSE;
2329 }
2330
2331 return TRUE;
2332 }
2333
2334
2335 /**************************************************************************
2336 * GetFileAttributesExA (KERNEL32.@)
2337 */
2338 BOOL WINAPI GetFileAttributesExA(
2339 LPCSTR filename, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2340 LPVOID lpFileInformation)
2341 {
2342 UNICODE_STRING filenameW;
2343 BOOL ret = FALSE;
2344
2345 if (!filename || !lpFileInformation)
2346 {
2347 SetLastError(ERROR_INVALID_PARAMETER);
2348 return FALSE;
2349 }
2350
2351 if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
2352 {
2353 ret = GetFileAttributesExW(filenameW.Buffer, fInfoLevelId, lpFileInformation);
2354 RtlFreeUnicodeString(&filenameW);
2355 }
2356 else
2357 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2358 return ret;
2359 }
Maarten's multimedia branch