files/file.c

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