git.oblomov.eu Git - wine/blob - files/file.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * TODO:
   8  *    Fix the CopyFileEx methods to implement the "extented" functionality.
   9  *    Right now, they simply call the CopyFile method.
  10  */
  11
  12 #include "config.h"
  13
  14 #include <assert.h>
  15 #include <ctype.h>
  16 #include <errno.h>
  17 #include <fcntl.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #ifdef HAVE_SYS_ERRNO_H
  22 #include <sys/errno.h>
  23 #endif
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #ifdef HAVE_SYS_MMAN_H
  27 #include <sys/mman.h>
  28 #endif
  29 #include <sys/time.h>
  30 #include <time.h>
  31 #include <unistd.h>
  32 #include <utime.h>
  33
  34 #include "winerror.h"
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "wine/winbase16.h"
  38 #include "wine/winestring.h"
  39 #include "drive.h"
  40 #include "device.h"
  41 #include "file.h"
  42 #include "global.h"
  43 #include "heap.h"
  44 #include "msdos.h"
  45 #include "options.h"
  46 #include "ldt.h"
  47 #include "process.h"
  48 #include "task.h"
  49 #include "wincon.h"
  50 #include "debugtools.h"
  51
  52 #include "server.h"
  53
  54 DEFAULT_DEBUG_CHANNEL(file);
  55
  56 #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
  57 #define MAP_ANON MAP_ANONYMOUS
  58 #endif
  59
  60 /* Size of per-process table of DOS handles */
  61 #define DOS_TABLE_SIZE 256
  62
  63
  64 /***********************************************************************
  65  *              FILE_ConvertOFMode
  66  *
  67  * Convert OF_* mode into flags for CreateFile.
  68  */
  69 static void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
  70 {
  71     switch(mode & 0x03)
  72     {
  73     case OF_READ:      *access = GENERIC_READ; break;
  74     case OF_WRITE:     *access = GENERIC_WRITE; break;
  75     case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
  76     default:           *access = 0; break;
  77     }
  78     switch(mode & 0x70)
  79     {
  80     case OF_SHARE_EXCLUSIVE:  *sharing = 0; break;
  81     case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
  82     case OF_SHARE_DENY_READ:  *sharing = FILE_SHARE_WRITE; break;
  83     case OF_SHARE_DENY_NONE:
  84     case OF_SHARE_COMPAT:
  85     default:                  *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
  86     }
  87 }
  88
  89
  90 #if 0
  91 /***********************************************************************
  92  *              FILE_ShareDeny
  93  *
  94  * PARAMS
  95  *       oldmode[I] mode how file was first opened
  96  *       mode[I] mode how the file should get opened
  97  * RETURNS
  98  *      TRUE: deny open
  99  *      FALSE: allow open
 100  *
 101  * Look what we have to do with the given SHARE modes
 102  *
 103  * Ralph Brown's interrupt list gives following explication, I guess
 104  * the same holds for Windows, DENY ALL should be OF_SHARE_COMPAT
 105  *
 106  * FIXME: Validate this function
 107 ========from Ralph Brown's list =========
 108 (Table 0750)
 109 Values of DOS file sharing behavior:
 110           |     Second and subsequent Opens
 111  First    |Compat  Deny   Deny   Deny   Deny
 112  Open     |        All    Write  Read   None
 113           |R W RW R W RW R W RW R W RW R W RW
 114  - - - - -| - - - - - - - - - - - - - - - - -
 115  Compat R |Y Y Y  N N N  1 N N  N N N  1 N N
 116         W |Y Y Y  N N N  N N N  N N N  N N N
 117         RW|Y Y Y  N N N  N N N  N N N  N N N
 118  - - - - -|
 119  Deny   R |C C C  N N N  N N N  N N N  N N N
 120  All    W |C C C  N N N  N N N  N N N  N N N
 121         RW|C C C  N N N  N N N  N N N  N N N
 122  - - - - -|
 123  Deny   R |2 C C  N N N  Y N N  N N N  Y N N
 124  Write  W |C C C  N N N  N N N  Y N N  Y N N
 125         RW|C C C  N N N  N N N  N N N  Y N N
 126  - - - - -|
 127  Deny   R |C C C  N N N  N Y N  N N N  N Y N
 128  Read   W |C C C  N N N  N N N  N Y N  N Y N
 129         RW|C C C  N N N  N N N  N N N  N Y N
 130  - - - - -|
 131  Deny   R |2 C C  N N N  Y Y Y  N N N  Y Y Y
 132  None   W |C C C  N N N  N N N  Y Y Y  Y Y Y
 133         RW|C C C  N N N  N N N  N N N  Y Y Y
 134 Legend: Y = open succeeds, N = open fails with error code 05h
 135         C = open fails, INT 24 generated
 136         1 = open succeeds if file read-only, else fails with error code
 137         2 = open succeeds if file read-only, else fails with INT 24
 138 ========end of description from Ralph Brown's List =====
 139         For every "Y" in the table we return FALSE
 140         For every "N" we set the DOS_ERROR and return TRUE
 141         For all other cases we barf,set the DOS_ERROR and return TRUE
 142
 143  */
 144 static BOOL FILE_ShareDeny( int mode, int oldmode)
 145 {
 146   int oldsharemode = oldmode & 0x70;
 147   int sharemode    =    mode & 0x70;
 148   int oldopenmode  = oldmode & 3;
 149   int openmode     =    mode & 3;
 150
 151   switch (oldsharemode)
 152     {
 153     case OF_SHARE_COMPAT:
 154       if (sharemode == OF_SHARE_COMPAT) return FALSE;
 155       if (openmode  == OF_READ) goto test_ro_err05 ;
 156       goto fail_error05;
 157     case OF_SHARE_EXCLUSIVE:
 158       if (sharemode == OF_SHARE_COMPAT) goto fail_int24;
 159       goto fail_error05;
 160     case OF_SHARE_DENY_WRITE:
 161       if (openmode  != OF_READ)
 162         {
 163           if (sharemode == OF_SHARE_COMPAT) goto fail_int24;
 164           goto fail_error05;
 165         }
 166       switch (sharemode)
 167         {
 168         case OF_SHARE_COMPAT:
 169           if (oldopenmode == OF_READ) goto test_ro_int24 ;
 170           goto fail_int24;
 171         case OF_SHARE_DENY_NONE :
 172           return FALSE;
 173         case OF_SHARE_DENY_WRITE :
 174           if (oldopenmode == OF_READ) return FALSE;
 175         case OF_SHARE_DENY_READ :
 176           if (oldopenmode == OF_WRITE) return FALSE;
 177         case OF_SHARE_EXCLUSIVE:
 178         default:
 179           goto fail_error05;
 180         }
 181       break;
 182     case OF_SHARE_DENY_READ:
 183       if (openmode  != OF_WRITE)
 184         {
 185           if (sharemode == OF_SHARE_COMPAT) goto fail_int24;
 186           goto fail_error05;
 187         }
 188       switch (sharemode)
 189         {
 190         case OF_SHARE_COMPAT:
 191           goto fail_int24;
 192         case OF_SHARE_DENY_NONE :
 193           return FALSE;
 194         case OF_SHARE_DENY_WRITE :
 195           if (oldopenmode == OF_READ) return FALSE;
 196         case OF_SHARE_DENY_READ :
 197           if (oldopenmode == OF_WRITE) return FALSE;
 198         case OF_SHARE_EXCLUSIVE:
 199         default:
 200           goto fail_error05;
 201         }
 202       break;
 203     case OF_SHARE_DENY_NONE:
 204       switch (sharemode)
 205         {
 206         case OF_SHARE_COMPAT:
 207           goto fail_int24;
 208         case OF_SHARE_DENY_NONE :
 209           return FALSE;
 210         case OF_SHARE_DENY_WRITE :
 211           if (oldopenmode == OF_READ) return FALSE;
 212         case OF_SHARE_DENY_READ :
 213           if (oldopenmode == OF_WRITE) return FALSE;
 214         case OF_SHARE_EXCLUSIVE:
 215         default:
 216           goto fail_error05;
 217         }
 218     default:
 219       ERR("unknown mode\n");
 220     }
 221   ERR("shouldn't happen\n");
 222   ERR("Please report to bon@elektron.ikp.physik.tu-darmstadt.de\n");
 223   return TRUE;
 224
 225 test_ro_int24:
 226   if (oldmode == OF_READ)
 227     return FALSE;
 228   /* Fall through */
 229 fail_int24:
 230   FIXME("generate INT24 missing\n");
 231   /* Is this the right error? */
 232   SetLastError( ERROR_ACCESS_DENIED );
 233   return TRUE;
 234
 235 test_ro_err05:
 236   if (oldmode == OF_READ)
 237     return FALSE;
 238   /* fall through */
 239 fail_error05:
 240   TRACE("Access Denied, oldmode 0x%02x mode 0x%02x\n",oldmode,mode);
 241   SetLastError( ERROR_ACCESS_DENIED );
 242   return TRUE;
 243 }
 244 #endif
 245
 246
 247 /***********************************************************************
 248  *           FILE_SetDosError
 249  *
 250  * Set the DOS error code from errno.
 251  */
 252 void FILE_SetDosError(void)
 253 {
 254     int save_errno = errno; /* errno gets overwritten by printf */
 255
 256     TRACE("errno = %d %s\n", errno, strerror(errno));
 257     switch (save_errno)
 258     {
 259     case EAGAIN:
 260         SetLastError( ERROR_SHARING_VIOLATION );
 261         break;
 262     case EBADF:
 263         SetLastError( ERROR_INVALID_HANDLE );
 264         break;
 265     case ENOSPC:
 266         SetLastError( ERROR_HANDLE_DISK_FULL );
 267         break;
 268     case EACCES:
 269     case EPERM:
 270     case EROFS:
 271         SetLastError( ERROR_ACCESS_DENIED );
 272         break;
 273     case EBUSY:
 274         SetLastError( ERROR_LOCK_VIOLATION );
 275         break;
 276     case ENOENT:
 277         SetLastError( ERROR_FILE_NOT_FOUND );
 278         break;
 279     case EISDIR:
 280         SetLastError( ERROR_CANNOT_MAKE );
 281         break;
 282     case ENFILE:
 283     case EMFILE:
 284         SetLastError( ERROR_NO_MORE_FILES );
 285         break;
 286     case EEXIST:
 287         SetLastError( ERROR_FILE_EXISTS );
 288         break;
 289     case EINVAL:
 290     case ESPIPE:
 291         SetLastError( ERROR_SEEK );
 292         break;
 293     case ENOTEMPTY:
 294         SetLastError( ERROR_DIR_NOT_EMPTY );
 295         break;
 296     default:
 297         perror( "int21: unknown errno" );
 298         SetLastError( ERROR_GEN_FAILURE );
 299         break;
 300     }
 301     errno = save_errno;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           FILE_DupUnixHandle
 307  *
 308  * Duplicate a Unix handle into a task handle.
 309  */
 310 HFILE FILE_DupUnixHandle( int fd, DWORD access )
 311 {
 312     int unix_handle;
 313     struct alloc_file_handle_request *req = get_req_buffer();
 314
 315     if ((unix_handle = dup(fd)) == -1)
 316     {
 317         FILE_SetDosError();
 318         return INVALID_HANDLE_VALUE;
 319     }
 320     req->access  = access;
 321     server_call_fd( REQ_ALLOC_FILE_HANDLE, unix_handle, NULL );
 322     return req->handle;
 323 }
 324
 325
 326 /***********************************************************************
 327  *           FILE_CreateFile
 328  *
 329  * Implementation of CreateFile. Takes a Unix path name.
 330  */
 331 HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
 332                          LPSECURITY_ATTRIBUTES sa, DWORD creation,
 333                          DWORD attributes, HANDLE template )
 334 {
 335     struct create_file_request *req = get_req_buffer();
 336
 337     req->access  = access;
 338     req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 339     req->sharing = sharing;
 340     req->create  = creation;
 341     req->attrs   = attributes;
 342     lstrcpynA( req->name, filename, server_remaining(req->name) );
 343     SetLastError(0);
 344     server_call( REQ_CREATE_FILE );
 345
 346     /* If write access failed, retry without GENERIC_WRITE */
 347
 348     if ((req->handle == -1) && !Options.failReadOnly &&
 349         (access & GENERIC_WRITE))
 350     {
 351         DWORD lasterror = GetLastError();
 352
 353         if ((lasterror == ERROR_ACCESS_DENIED) ||
 354             (lasterror == ERROR_WRITE_PROTECT)) {
 355             TRACE("Write access failed for file '%s', trying without "
 356                   "write access", filename);
 357             return FILE_CreateFile( filename, access & ~GENERIC_WRITE, sharing,
 358                                     sa, creation, attributes, template );
 359     }
 360     }
 361
 362     if (req->handle == -1)
 363         WARN("Unable to create file '%s' (GLE %ld)", filename,
 364              GetLastError());
 365
 366     return req->handle;
 367 }
 368
 369
 370 /***********************************************************************
 371  *           FILE_CreateDevice
 372  *
 373  * Same as FILE_CreateFile but for a device
 374  */
 375 HFILE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
 376 {
 377     struct create_device_request *req = get_req_buffer();
 378
 379     req->access  = access;
 380     req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 381     req->id      = client_id;
 382     SetLastError(0);
 383     server_call( REQ_CREATE_DEVICE );
 384     return req->handle;
 385 }
 386
 387
 388 /*************************************************************************
 389  * CreateFile32A [KERNEL32.45]  Creates or opens a file or other object
 390  *
 391  * Creates or opens an object, and returns a handle that can be used to
 392  * access that object.
 393  *
 394  * PARAMS
 395  *
 396  * filename     [I] pointer to filename to be accessed
 397  * access       [I] access mode requested
 398  * sharing      [I] share mode
 399  * sa           [I] pointer to security attributes
 400  * creation     [I] how to create the file
 401  * attributes   [I] attributes for newly created file
 402  * template     [I] handle to file with extended attributes to copy
 403  *
 404  * RETURNS
 405  *   Success: Open handle to specified file
 406  *   Failure: INVALID_HANDLE_VALUE
 407  *
 408  * NOTES
 409  *  Should call SetLastError() on failure.
 410  *
 411  * BUGS
 412  *
 413  * Doesn't support character devices, pipes, template files, or a
 414  * lot of the 'attributes' flags yet.
 415  */
 416 HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
 417                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 418                               DWORD attributes, HANDLE template )
 419 {
 420     DOS_FULL_NAME full_name;
 421
 422     if (!filename)
 423     {
 424         SetLastError( ERROR_INVALID_PARAMETER );
 425         return HFILE_ERROR;
 426     }
 427     TRACE("%s %s%s%s%s%s%s%s\n",filename,
 428           ((access & GENERIC_READ)==GENERIC_READ)?"GENERIC_READ ":"",
 429           ((access & GENERIC_WRITE)==GENERIC_WRITE)?"GENERIC_WRITE ":"",
 430           (!access)?"QUERY_ACCESS ":"",
 431           ((sharing & FILE_SHARE_READ)==FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
 432           ((sharing & FILE_SHARE_WRITE)==FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
 433           ((sharing & FILE_SHARE_DELETE)==FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
 434           (creation ==CREATE_NEW)?"CREATE_NEW":
 435           (creation ==CREATE_ALWAYS)?"CREATE_ALWAYS ":
 436           (creation ==OPEN_EXISTING)?"OPEN_EXISTING ":
 437           (creation ==OPEN_ALWAYS)?"OPEN_ALWAYS ":
 438           (creation ==TRUNCATE_EXISTING)?"TRUNCATE_EXISTING ":"");
 439
 440     /* If the name starts with '\\?\', ignore the first 4 chars. */
 441     if (!strncmp(filename, "\\\\?\\", 4))
 442     {
 443         filename += 4;
 444         if (!strncmp(filename, "UNC\\", 4))
 445         {
 446             FIXME("UNC name (%s) not supported.\n", filename );
 447             SetLastError( ERROR_PATH_NOT_FOUND );
 448             return HFILE_ERROR;
 449         }
 450     }
 451
 452     if (!strncmp(filename, "\\\\.\\", 4)) {
 453         if (!DOSFS_GetDevice( filename ))
 454                 return DEVICE_Open( filename+4, access, sa );
 455         else
 456                 filename+=4; /* fall into DOSFS_Device case below */
 457     }
 458
 459     /* If the name still starts with '\\', it's a UNC name. */
 460     if (!strncmp(filename, "\\\\", 2))
 461     {
 462         FIXME("UNC name (%s) not supported.\n", filename );
 463         SetLastError( ERROR_PATH_NOT_FOUND );
 464         return HFILE_ERROR;
 465     }
 466
 467     /* If the name contains a DOS wild card (* or ?), do no create a file */
 468     if(strchr(filename,'*') || strchr(filename,'?'))
 469         return HFILE_ERROR;
 470
 471     /* Open a console for CONIN$ or CONOUT$ */
 472     if (!lstrcmpiA(filename, "CONIN$")) return CONSOLE_OpenHandle( FALSE, access, sa );
 473     if (!lstrcmpiA(filename, "CONOUT$")) return CONSOLE_OpenHandle( TRUE, access, sa );
 474
 475     if (DOSFS_GetDevice( filename ))
 476     {
 477         HFILE   ret;
 478
 479         TRACE("opening device '%s'\n", filename );
 480
 481         if (HFILE_ERROR!=(ret=DOSFS_OpenDevice( filename, access )))
 482                 return ret;
 483
 484         /* Do not silence this please. It is a critical error. -MM */
 485         ERR("Couldn't open device '%s'!\n",filename);
 486         SetLastError( ERROR_FILE_NOT_FOUND );
 487         return HFILE_ERROR;
 488     }
 489
 490     /* check for filename, don't check for last entry if creating */
 491     if (!DOSFS_GetFullName( filename,
 492                             (creation == OPEN_EXISTING) ||
 493                             (creation == TRUNCATE_EXISTING),
 494                             &full_name )) {
 495         WARN("Unable to get full filename from '%s' (GLE %ld)\n",
 496              filename, GetLastError());
 497         return HFILE_ERROR;
 498     }
 499
 500     return FILE_CreateFile( full_name.long_name, access, sharing,
 501                             sa, creation, attributes, template );
 502 }
 503
 504
 505
 506 /*************************************************************************
 507  *              CreateFile32W              (KERNEL32.48)
 508  */
 509 HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
 510                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 511                               DWORD attributes, HANDLE template)
 512 {
 513     LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 514     HANDLE res = CreateFileA( afn, access, sharing, sa, creation, attributes, template );
 515     HeapFree( GetProcessHeap(), 0, afn );
 516     return res;
 517 }
 518
 519
 520 /***********************************************************************
 521  *           FILE_FillInfo
 522  *
 523  * Fill a file information from a struct stat.
 524  */
 525 static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
 526 {
 527     if (S_ISDIR(st->st_mode))
 528         info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 529     else
 530         info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
 531     if (!(st->st_mode & S_IWUSR))
 532         info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
 533
 534     DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftCreationTime, 0 );
 535     DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftLastWriteTime, 0 );
 536     DOSFS_UnixTimeToFileTime( st->st_atime, &info->ftLastAccessTime, 0 );
 537
 538     info->dwVolumeSerialNumber = 0;  /* FIXME */
 539     info->nFileSizeHigh = 0;
 540     info->nFileSizeLow  = S_ISDIR(st->st_mode) ? 0 : st->st_size;
 541     info->nNumberOfLinks = st->st_nlink;
 542     info->nFileIndexHigh = 0;
 543     info->nFileIndexLow  = st->st_ino;
 544 }
 545
 546
 547 /***********************************************************************
 548  *           FILE_Stat
 549  *
 550  * Stat a Unix path name. Return TRUE if OK.
 551  */
 552 BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
 553 {
 554     struct stat st;
 555
 556     if (!unixName || !info) return FALSE;
 557
 558     if (stat( unixName, &st ) == -1)
 559     {
 560         FILE_SetDosError();
 561         return FALSE;
 562     }
 563     FILE_FillInfo( &st, info );
 564     return TRUE;
 565 }
 566
 567
 568 /***********************************************************************
 569  *             GetFileInformationByHandle   (KERNEL32.219)
 570  */
 571 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
 572                                          BY_HANDLE_FILE_INFORMATION *info )
 573 {
 574     struct get_file_info_request *req = get_req_buffer();
 575
 576     if (!info) return 0;
 577     req->handle = hFile;
 578     if (server_call( REQ_GET_FILE_INFO )) return 0;
 579     DOSFS_UnixTimeToFileTime( req->write_time, &info->ftCreationTime, 0 );
 580     DOSFS_UnixTimeToFileTime( req->write_time, &info->ftLastWriteTime, 0 );
 581     DOSFS_UnixTimeToFileTime( req->access_time, &info->ftLastAccessTime, 0 );
 582     info->dwFileAttributes     = req->attr;
 583     info->dwVolumeSerialNumber = req->serial;
 584     info->nFileSizeHigh        = req->size_high;
 585     info->nFileSizeLow         = req->size_low;
 586     info->nNumberOfLinks       = req->links;
 587     info->nFileIndexHigh       = req->index_high;
 588     info->nFileIndexLow        = req->index_low;
 589     return 1;
 590 }
 591
 592
 593 /**************************************************************************
 594  *           GetFileAttributes16   (KERNEL.420)
 595  */
 596 DWORD WINAPI GetFileAttributes16( LPCSTR name )
 597 {
 598     return GetFileAttributesA( name );
 599 }
 600
 601
 602 /**************************************************************************
 603  *           GetFileAttributes32A   (KERNEL32.217)
 604  */
 605 DWORD WINAPI GetFileAttributesA( LPCSTR name )
 606 {
 607     DOS_FULL_NAME full_name;
 608     BY_HANDLE_FILE_INFORMATION info;
 609
 610     if (name == NULL || *name=='\0') return -1;
 611
 612     if (!DOSFS_GetFullName( name, TRUE, &full_name )) return -1;
 613     if (!FILE_Stat( full_name.long_name, &info )) return -1;
 614     return info.dwFileAttributes;
 615 }
 616
 617
 618 /**************************************************************************
 619  *           GetFileAttributes32W   (KERNEL32.218)
 620  */
 621 DWORD WINAPI GetFileAttributesW( LPCWSTR name )
 622 {
 623     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 624     DWORD res = GetFileAttributesA( nameA );
 625     HeapFree( GetProcessHeap(), 0, nameA );
 626     return res;
 627 }
 628
 629
 630 /***********************************************************************
 631  *           GetFileSize   (KERNEL32.220)
 632  */
 633 DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD filesizehigh )
 634 {
 635     BY_HANDLE_FILE_INFORMATION info;
 636     if (!GetFileInformationByHandle( hFile, &info )) return 0;
 637     if (filesizehigh) *filesizehigh = info.nFileSizeHigh;
 638     return info.nFileSizeLow;
 639 }
 640
 641
 642 /***********************************************************************
 643  *           GetFileTime   (KERNEL32.221)
 644  */
 645 BOOL WINAPI GetFileTime( HANDLE hFile, FILETIME *lpCreationTime,
 646                            FILETIME *lpLastAccessTime,
 647                            FILETIME *lpLastWriteTime )
 648 {
 649     BY_HANDLE_FILE_INFORMATION info;
 650     if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
 651     if (lpCreationTime)   *lpCreationTime   = info.ftCreationTime;
 652     if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
 653     if (lpLastWriteTime)  *lpLastWriteTime  = info.ftLastWriteTime;
 654     return TRUE;
 655 }
 656
 657 /***********************************************************************
 658  *           CompareFileTime   (KERNEL32.28)
 659  */
 660 INT WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
 661 {
 662         if (!x || !y) return -1;
 663
 664         if (x->dwHighDateTime > y->dwHighDateTime)
 665                 return 1;
 666         if (x->dwHighDateTime < y->dwHighDateTime)
 667                 return -1;
 668         if (x->dwLowDateTime > y->dwLowDateTime)
 669                 return 1;
 670         if (x->dwLowDateTime < y->dwLowDateTime)
 671                 return -1;
 672         return 0;
 673 }
 674
 675 /***********************************************************************
 676  *           FILE_GetTempFileName : utility for GetTempFileName
 677  */
 678 static UINT FILE_GetTempFileName( LPCSTR path, LPCSTR prefix, UINT unique,
 679                                   LPSTR buffer, BOOL isWin16 )
 680 {
 681     static UINT unique_temp;
 682     DOS_FULL_NAME full_name;
 683     int i;
 684     LPSTR p;
 685     UINT num;
 686
 687     if ( !path || !prefix || !buffer ) return 0;
 688
 689     if (!unique_temp) unique_temp = time(NULL) & 0xffff;
 690     num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff);
 691
 692     strcpy( buffer, path );
 693     p = buffer + strlen(buffer);
 694
 695     /* add a \, if there isn't one and path is more than just the drive letter ... */
 696     if ( !((strlen(buffer) == 2) && (buffer[1] == ':'))
 697         && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\';
 698
 699     if (isWin16) *p++ = '~';
 700     for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
 701     sprintf( p, "%04x.tmp", num );
 702
 703     /* Now try to create it */
 704
 705     if (!unique)
 706     {
 707         do
 708         {
 709             HFILE handle = CreateFileA( buffer, GENERIC_WRITE, 0, NULL,
 710                                             CREATE_NEW, FILE_ATTRIBUTE_NORMAL, -1 );
 711             if (handle != INVALID_HANDLE_VALUE)
 712             {  /* We created it */
 713                 TRACE("created %s\n",
 714                               buffer);
 715                 CloseHandle( handle );
 716                 break;
 717             }
 718             if (GetLastError() != ERROR_FILE_EXISTS)
 719                 break;  /* No need to go on */
 720             num++;
 721             sprintf( p, "%04x.tmp", num );
 722         } while (num != (unique & 0xffff));
 723     }
 724
 725     /* Get the full path name */
 726
 727     if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
 728     {
 729         /* Check if we have write access in the directory */
 730         if ((p = strrchr( full_name.long_name, '/' ))) *p = '\0';
 731         if (access( full_name.long_name, W_OK ) == -1)
 732             WARN("returns '%s', which doesn't seem to be writeable.\n",
 733                  buffer);
 734     }
 735     TRACE("returning %s\n", buffer );
 736     return unique ? unique : num;
 737 }
 738
 739
 740 /***********************************************************************
 741  *           GetTempFileName32A   (KERNEL32.290)
 742  */
 743 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
 744                                   LPSTR buffer)
 745 {
 746     return FILE_GetTempFileName(path, prefix, unique, buffer, FALSE);
 747 }
 748
 749 /***********************************************************************
 750  *           GetTempFileName32W   (KERNEL32.291)
 751  */
 752 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
 753                                   LPWSTR buffer )
 754 {
 755     LPSTR   patha,prefixa;
 756     char    buffera[144];
 757     UINT  ret;
 758
 759     if (!path) return 0;
 760     patha   = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
 761     prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
 762     ret     = FILE_GetTempFileName( patha, prefixa, unique, buffera, FALSE );
 763     lstrcpyAtoW( buffer, buffera );
 764     HeapFree( GetProcessHeap(), 0, patha );
 765     HeapFree( GetProcessHeap(), 0, prefixa );
 766     return ret;
 767 }
 768
 769
 770 /***********************************************************************
 771  *           GetTempFileName16   (KERNEL.97)
 772  */
 773 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
 774                                  LPSTR buffer )
 775 {
 776     char temppath[144];
 777
 778     if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
 779         drive |= DRIVE_GetCurrentDrive() + 'A';
 780
 781     if ((drive & TF_FORCEDRIVE) &&
 782         !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
 783     {
 784         drive &= ~TF_FORCEDRIVE;
 785         WARN("invalid drive %d specified\n", drive );
 786     }
 787
 788     if (drive & TF_FORCEDRIVE)
 789         sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
 790     else
 791         GetTempPathA( 132, temppath );
 792     return (UINT16)FILE_GetTempFileName( temppath, prefix, unique, buffer, TRUE );
 793 }
 794
 795 /***********************************************************************
 796  *           FILE_DoOpenFile
 797  *
 798  * Implementation of OpenFile16() and OpenFile32().
 799  */
 800 static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode,
 801                                 BOOL win32 )
 802 {
 803     HFILE hFileRet;
 804     FILETIME filetime;
 805     WORD filedatetime[2];
 806     DOS_FULL_NAME full_name;
 807     DWORD access, sharing;
 808     char *p;
 809
 810     if (!ofs) return HFILE_ERROR;
 811
 812     TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",name,
 813           ((mode & 0x3 )==OF_READ)?"OF_READ":
 814           ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
 815           ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
 816           ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
 817           ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
 818           ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
 819           ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
 820           ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
 821           ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
 822           ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
 823           ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
 824           ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
 825           ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
 826           ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
 827           ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
 828           ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
 829           ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
 830           );
 831
 832
 833     ofs->cBytes = sizeof(OFSTRUCT);
 834     ofs->nErrCode = 0;
 835     if (mode & OF_REOPEN) name = ofs->szPathName;
 836
 837     if (!name) {
 838         ERR("called with `name' set to NULL ! Please debug.\n");
 839         return HFILE_ERROR;
 840     }
 841
 842     TRACE("%s %04x\n", name, mode );
 843
 844     /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
 845        Are there any cases where getting the path here is wrong?
 846        Uwe Bonnes 1997 Apr 2 */
 847     if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
 848                              ofs->szPathName, NULL )) goto error;
 849     FILE_ConvertOFMode( mode, &access, &sharing );
 850
 851     /* OF_PARSE simply fills the structure */
 852
 853     if (mode & OF_PARSE)
 854     {
 855         ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
 856                            != DRIVE_REMOVABLE);
 857         TRACE("(%s): OF_PARSE, res = '%s'\n",
 858                       name, ofs->szPathName );
 859         return 0;
 860     }
 861
 862     /* OF_CREATE is completely different from all other options, so
 863        handle it first */
 864
 865     if (mode & OF_CREATE)
 866     {
 867         if ((hFileRet = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
 868                                        sharing, NULL, CREATE_ALWAYS,
 869                                        FILE_ATTRIBUTE_NORMAL, -1 ))== INVALID_HANDLE_VALUE)
 870             goto error;
 871         goto success;
 872     }
 873
 874     /* If OF_SEARCH is set, ignore the given path */
 875
 876     if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
 877     {
 878         /* First try the file name as is */
 879         if (DOSFS_GetFullName( name, TRUE, &full_name )) goto found;
 880         /* Now remove the path */
 881         if (name[0] && (name[1] == ':')) name += 2;
 882         if ((p = strrchr( name, '\\' ))) name = p + 1;
 883         if ((p = strrchr( name, '/' ))) name = p + 1;
 884         if (!name[0]) goto not_found;
 885     }
 886
 887     /* Now look for the file */
 888
 889     if (!DIR_SearchPath( NULL, name, NULL, &full_name, win32 )) goto not_found;
 890
 891 found:
 892     TRACE("found %s = %s\n",
 893                   full_name.long_name, full_name.short_name );
 894     lstrcpynA( ofs->szPathName, full_name.short_name,
 895                  sizeof(ofs->szPathName) );
 896
 897     if (mode & OF_SHARE_EXCLUSIVE)
 898       /* Some InstallShield version uses OF_SHARE_EXCLUSIVE
 899          on the file <tempdir>/_ins0432._mp to determine how
 900          far installation has proceeded.
 901          _ins0432._mp is an executable and while running the
 902          application expects the open with OF_SHARE_ to fail*/
 903       /* Probable FIXME:
 904          As our loader closes the files after loading the executable,
 905          we can't find the running executable with FILE_InUse.
 906          Perhaps the loader should keep the file open.
 907          Recheck against how Win handles that case */
 908       {
 909         char *last = strrchr(full_name.long_name,'/');
 910         if (!last)
 911           last = full_name.long_name - 1;
 912         if (GetModuleHandle16(last+1))
 913           {
 914             TRACE("Denying shared open for %s\n",full_name.long_name);
 915             return HFILE_ERROR;
 916           }
 917       }
 918
 919     if (mode & OF_DELETE)
 920     {
 921         if (unlink( full_name.long_name ) == -1) goto not_found;
 922         TRACE("(%s): OF_DELETE return = OK\n", name);
 923         return 1;
 924     }
 925
 926     hFileRet = FILE_CreateFile( full_name.long_name, access, sharing,
 927                                 NULL, OPEN_EXISTING, 0, -1 );
 928     if (hFileRet == HFILE_ERROR) goto not_found;
 929
 930     GetFileTime( hFileRet, NULL, NULL, &filetime );
 931     FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
 932     if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
 933     {
 934         if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
 935         {
 936             CloseHandle( hFileRet );
 937             WARN("(%s): OF_VERIFY failed\n", name );
 938             /* FIXME: what error here? */
 939             SetLastError( ERROR_FILE_NOT_FOUND );
 940             goto error;
 941         }
 942     }
 943     memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
 944
 945 success:  /* We get here if the open was successful */
 946     TRACE("(%s): OK, return = %d\n", name, hFileRet );
 947     if (win32)
 948     {
 949         if (mode & OF_EXIST) /* Return the handle, but close it first */
 950             CloseHandle( hFileRet );
 951     }
 952     else
 953     {
 954         hFileRet = FILE_AllocDosHandle( hFileRet );
 955         if (hFileRet == HFILE_ERROR16) goto error;
 956         if (mode & OF_EXIST) /* Return the handle, but close it first */
 957             _lclose16( hFileRet );
 958     }
 959     return hFileRet;
 960
 961 not_found:  /* We get here if the file does not exist */
 962     WARN("'%s' not found\n", name );
 963     SetLastError( ERROR_FILE_NOT_FOUND );
 964     /* fall through */
 965
 966 error:  /* We get here if there was an error opening the file */
 967     ofs->nErrCode = GetLastError();
 968     WARN("(%s): return = HFILE_ERROR error= %d\n",
 969                   name,ofs->nErrCode );
 970     return HFILE_ERROR;
 971 }
 972
 973
 974 /***********************************************************************
 975  *           OpenFile16   (KERNEL.74)
 976  */
 977 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
 978 {
 979     return FILE_DoOpenFile( name, ofs, mode, FALSE );
 980 }
 981
 982
 983 /***********************************************************************
 984  *           OpenFile32   (KERNEL32.396)
 985  */
 986 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
 987 {
 988     return FILE_DoOpenFile( name, ofs, mode, TRUE );
 989 }
 990
 991
 992 /***********************************************************************
 993  *           FILE_InitProcessDosHandles
 994  *
 995  * Allocates the default DOS handles for a process. Called either by
 996  * AllocDosHandle below or by the DOSVM stuff.
 997  */
 998 BOOL FILE_InitProcessDosHandles( void ) {
 999         HANDLE *ptr;
1000
1001         if (!(ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1002                                sizeof(*ptr) * DOS_TABLE_SIZE )))
1003             return FALSE;
1004         PROCESS_Current()->dos_handles = ptr;
1005         ptr[0] = GetStdHandle(STD_INPUT_HANDLE);
1006         ptr[1] = GetStdHandle(STD_OUTPUT_HANDLE);
1007         ptr[2] = GetStdHandle(STD_ERROR_HANDLE);
1008         ptr[3] = GetStdHandle(STD_ERROR_HANDLE);
1009         ptr[4] = GetStdHandle(STD_ERROR_HANDLE);
1010         return TRUE;
1011 }
1012
1013 /***********************************************************************
1014  *           FILE_AllocDosHandle
1015  *
1016  * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
1017  * longer valid after this function (even on failure).
1018  */
1019 HFILE16 FILE_AllocDosHandle( HANDLE handle )
1020 {
1021     int i;
1022     HANDLE *ptr = PROCESS_Current()->dos_handles;
1023
1024     if (!handle || (handle == INVALID_HANDLE_VALUE))
1025         return INVALID_HANDLE_VALUE16;
1026
1027     if (!ptr) {
1028         if (!FILE_InitProcessDosHandles())
1029             goto error;
1030         ptr = PROCESS_Current()->dos_handles;
1031     }
1032
1033     for (i = 0; i < DOS_TABLE_SIZE; i++, ptr++)
1034         if (!*ptr)
1035         {
1036             *ptr = handle;
1037             TRACE("Got %d for h32 %d\n", i, handle );
1038             return i;
1039         }
1040 error:
1041     CloseHandle( handle );
1042     SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1043     return INVALID_HANDLE_VALUE16;
1044 }
1045
1046
1047 /***********************************************************************
1048  *           FILE_GetHandle32
1049  *
1050  * Return the Win32 handle for a DOS handle.
1051  */
1052 HANDLE FILE_GetHandle( HFILE16 hfile )
1053 {
1054     HANDLE *table = PROCESS_Current()->dos_handles;
1055     if ((hfile >= DOS_TABLE_SIZE) || !table || !table[hfile])
1056     {
1057         SetLastError( ERROR_INVALID_HANDLE );
1058         return INVALID_HANDLE_VALUE;
1059     }
1060     return table[hfile];
1061 }
1062
1063
1064 /***********************************************************************
1065  *           FILE_Dup2
1066  *
1067  * dup2() function for DOS handles.
1068  */
1069 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1070 {
1071     HANDLE *table = PROCESS_Current()->dos_handles;
1072     HANDLE new_handle;
1073
1074     if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) ||
1075         !table || !table[hFile1])
1076     {
1077         SetLastError( ERROR_INVALID_HANDLE );
1078         return HFILE_ERROR16;
1079     }
1080     if (hFile2 < 5)
1081     {
1082         FIXME("stdio handle closed, need proper conversion\n" );
1083         SetLastError( ERROR_INVALID_HANDLE );
1084         return HFILE_ERROR16;
1085     }
1086     if (!DuplicateHandle( GetCurrentProcess(), table[hFile1],
1087                           GetCurrentProcess(), &new_handle,
1088                           0, FALSE, DUPLICATE_SAME_ACCESS ))
1089         return HFILE_ERROR16;
1090     if (table[hFile2]) CloseHandle( table[hFile2] );
1091     table[hFile2] = new_handle;
1092     return hFile2;
1093 }
1094
1095
1096 /***********************************************************************
1097  *           _lclose16   (KERNEL.81)
1098  */
1099 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1100 {
1101     HANDLE *table = PROCESS_Current()->dos_handles;
1102
1103     if (hFile < 5)
1104     {
1105         FIXME("stdio handle closed, need proper conversion\n" );
1106         SetLastError( ERROR_INVALID_HANDLE );
1107         return HFILE_ERROR16;
1108     }
1109     if ((hFile >= DOS_TABLE_SIZE) || !table || !table[hFile])
1110     {
1111         SetLastError( ERROR_INVALID_HANDLE );
1112         return HFILE_ERROR16;
1113     }
1114     TRACE("%d (handle32=%d)\n", hFile, table[hFile] );
1115     CloseHandle( table[hFile] );
1116     table[hFile] = 0;
1117     return 0;
1118 }
1119
1120
1121 /***********************************************************************
1122  *           _lclose32   (KERNEL32.592)
1123  */
1124 HFILE WINAPI _lclose( HFILE hFile )
1125 {
1126     TRACE("handle %d\n", hFile );
1127     return CloseHandle( hFile ) ? 0 : HFILE_ERROR;
1128 }
1129
1130 /***********************************************************************
1131  *              GetOverlappedResult     (KERNEL32.360)
1132  */
1133 BOOL WINAPI GetOverlappedResult(HANDLE hFile,LPOVERLAPPED lpOverlapped,
1134                                 LPDWORD lpNumberOfBytesTransferred,
1135                                 BOOL bWait)
1136 {
1137     /* Since all i/o is currently synchronuos,
1138      * return true, assuming ReadFile/WriteFile
1139      * have completed the operation */
1140     FIXME("NO Asynch I/O, assuming Read/Write succeeded\n" );
1141     return TRUE;
1142 }
1143
1144 /***********************************************************************
1145  *              ReadFile                (KERNEL32.428)
1146  */
1147 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1148                         LPDWORD bytesRead, LPOVERLAPPED overlapped )
1149 {
1150     struct get_read_fd_request *req = get_req_buffer();
1151     int unix_handle, result;
1152
1153     TRACE("%d %p %ld\n", hFile, buffer, bytesToRead );
1154
1155     if (bytesRead) *bytesRead = 0;  /* Do this before anything else */
1156     if (!bytesToRead) return TRUE;
1157
1158     if ( overlapped ) {
1159       SetLastError ( ERROR_INVALID_PARAMETER );
1160       return FALSE;
1161     }
1162
1163     req->handle = hFile;
1164     server_call_fd( REQ_GET_READ_FD, -1, &unix_handle );
1165     if (unix_handle == -1) return FALSE;
1166     while ((result = read( unix_handle, buffer, bytesToRead )) == -1)
1167     {
1168         if ((errno == EAGAIN) || (errno == EINTR)) continue;
1169         if ((errno == EFAULT) && VIRTUAL_HandleFault( buffer )) continue;
1170         FILE_SetDosError();
1171         break;
1172     }
1173     close( unix_handle );
1174     if (result == -1) return FALSE;
1175     if (bytesRead) *bytesRead = result;
1176     return TRUE;
1177 }
1178
1179
1180 /***********************************************************************
1181  *             WriteFile               (KERNEL32.578)
1182  */
1183 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1184                          LPDWORD bytesWritten, LPOVERLAPPED overlapped )
1185 {
1186     struct get_write_fd_request *req = get_req_buffer();
1187     int unix_handle, result;
1188
1189     TRACE("%d %p %ld\n", hFile, buffer, bytesToWrite );
1190
1191     if (bytesWritten) *bytesWritten = 0;  /* Do this before anything else */
1192     if (!bytesToWrite) return TRUE;
1193
1194     if ( overlapped ) {
1195       SetLastError ( ERROR_INVALID_PARAMETER );
1196       return FALSE;
1197     }
1198
1199     req->handle = hFile;
1200     server_call_fd( REQ_GET_WRITE_FD, -1, &unix_handle );
1201     if (unix_handle == -1) return FALSE;
1202     while ((result = write( unix_handle, buffer, bytesToWrite )) == -1)
1203     {
1204         if ((errno == EAGAIN) || (errno == EINTR)) continue;
1205         if ((errno == EFAULT) && VIRTUAL_HandleFault( buffer )) continue;
1206         if (errno == ENOSPC)
1207             SetLastError( ERROR_DISK_FULL );
1208         else
1209         FILE_SetDosError();
1210         break;
1211     }
1212     close( unix_handle );
1213     if (result == -1) return FALSE;
1214     if (bytesWritten) *bytesWritten = result;
1215     return TRUE;
1216 }
1217
1218
1219 /***********************************************************************
1220  *           WIN16_hread
1221  */
1222 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
1223 {
1224     LONG maxlen;
1225
1226     TRACE("%d %08lx %ld\n",
1227                   hFile, (DWORD)buffer, count );
1228
1229     /* Some programs pass a count larger than the allocated buffer */
1230     maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
1231     if (count > maxlen) count = maxlen;
1232     return _lread(FILE_GetHandle(hFile), PTR_SEG_TO_LIN(buffer), count );
1233 }
1234
1235
1236 /***********************************************************************
1237  *           WIN16_lread
1238  */
1239 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
1240 {
1241     return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
1242 }
1243
1244
1245 /***********************************************************************
1246  *           _lread32   (KERNEL32.596)
1247  */
1248 UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
1249 {
1250     DWORD result;
1251     if (!ReadFile( handle, buffer, count, &result, NULL )) return -1;
1252     return result;
1253 }
1254
1255
1256 /***********************************************************************
1257  *           _lread16   (KERNEL.82)
1258  */
1259 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
1260 {
1261     return (UINT16)_lread(FILE_GetHandle(hFile), buffer, (LONG)count );
1262 }
1263
1264
1265 /***********************************************************************
1266  *           _lcreat16   (KERNEL.83)
1267  */
1268 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
1269 {
1270     return FILE_AllocDosHandle( _lcreat( path, attr ) );
1271 }
1272
1273
1274 /***********************************************************************
1275  *           _lcreat   (KERNEL32.593)
1276  */
1277 HFILE WINAPI _lcreat( LPCSTR path, INT attr )
1278 {
1279     /* Mask off all flags not explicitly allowed by the doc */
1280     attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
1281     TRACE("%s %02x\n", path, attr );
1282     return CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
1283                         FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1284                         CREATE_ALWAYS, attr, -1 );
1285 }
1286
1287
1288 /***********************************************************************
1289  *           SetFilePointer   (KERNEL32.492)
1290  */
1291 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
1292                              DWORD method )
1293 {
1294     struct set_file_pointer_request *req = get_req_buffer();
1295
1296     if (highword && *highword)
1297     {
1298         FIXME("64-bit offsets not supported yet\n");
1299         SetLastError( ERROR_INVALID_PARAMETER );
1300         return 0xffffffff;
1301     }
1302     TRACE("handle %d offset %ld origin %ld\n",
1303           hFile, distance, method );
1304
1305     req->handle = hFile;
1306     req->low = distance;
1307     req->high = highword ? *highword : 0;
1308     /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
1309     req->whence = method;
1310     SetLastError( 0 );
1311     if (server_call( REQ_SET_FILE_POINTER )) return 0xffffffff;
1312     if (highword) *highword = req->new_high;
1313     return req->new_low;
1314 }
1315
1316
1317 /***********************************************************************
1318  *           _llseek16   (KERNEL.84)
1319  *
1320  * FIXME:
1321  *   Seeking before the start of the file should be allowed for _llseek16,
1322  *   but cause subsequent I/O operations to fail (cf. interrupt list)
1323  *
1324  */
1325 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
1326 {
1327     return SetFilePointer( FILE_GetHandle(hFile), lOffset, NULL, nOrigin );
1328 }
1329
1330
1331 /***********************************************************************
1332  *           _llseek32   (KERNEL32.594)
1333  */
1334 LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
1335 {
1336     return SetFilePointer( hFile, lOffset, NULL, nOrigin );
1337 }
1338
1339
1340 /***********************************************************************
1341  *           _lopen16   (KERNEL.85)
1342  */
1343 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
1344 {
1345     return FILE_AllocDosHandle( _lopen( path, mode ) );
1346 }
1347
1348
1349 /***********************************************************************
1350  *           _lopen32   (KERNEL32.595)
1351  */
1352 HFILE WINAPI _lopen( LPCSTR path, INT mode )
1353 {
1354     DWORD access, sharing;
1355
1356     TRACE("('%s',%04x)\n", path, mode );
1357     FILE_ConvertOFMode( mode, &access, &sharing );
1358     return CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, -1 );
1359 }
1360
1361
1362 /***********************************************************************
1363  *           _lwrite16   (KERNEL.86)
1364  */
1365 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
1366 {
1367     return (UINT16)_hwrite( FILE_GetHandle(hFile), buffer, (LONG)count );
1368 }
1369
1370 /***********************************************************************
1371  *           _lwrite32   (KERNEL32.761)
1372  */
1373 UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
1374 {
1375     return (UINT)_hwrite( hFile, buffer, (LONG)count );
1376 }
1377
1378
1379 /***********************************************************************
1380  *           _hread16   (KERNEL.349)
1381  */
1382 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
1383 {
1384     return _lread( FILE_GetHandle(hFile), buffer, count );
1385 }
1386
1387
1388 /***********************************************************************
1389  *           _hread32   (KERNEL32.590)
1390  */
1391 LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
1392 {
1393     return _lread( hFile, buffer, count );
1394 }
1395
1396
1397 /***********************************************************************
1398  *           _hwrite16   (KERNEL.350)
1399  */
1400 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
1401 {
1402     return _hwrite( FILE_GetHandle(hFile), buffer, count );
1403 }
1404
1405
1406 /***********************************************************************
1407  *           _hwrite32   (KERNEL32.591)
1408  *
1409  *      experimentation yields that _lwrite:
1410  *              o truncates the file at the current position with
1411  *                a 0 len write
1412  *              o returns 0 on a 0 length write
1413  *              o works with console handles
1414  *
1415  */
1416 LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
1417 {
1418     DWORD result;
1419
1420     TRACE("%d %p %ld\n", handle, buffer, count );
1421
1422     if (!count)
1423     {
1424         /* Expand or truncate at current position */
1425         if (!SetEndOfFile( handle )) return HFILE_ERROR;
1426         return 0;
1427     }
1428     if (!WriteFile( handle, buffer, count, &result, NULL ))
1429         return HFILE_ERROR;
1430     return result;
1431 }
1432
1433
1434 /***********************************************************************
1435  *           SetHandleCount16   (KERNEL.199)
1436  */
1437 UINT16 WINAPI SetHandleCount16( UINT16 count )
1438 {
1439     HGLOBAL16 hPDB = GetCurrentPDB16();
1440     PDB16 *pdb = (PDB16 *)GlobalLock16( hPDB );
1441     BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
1442
1443     TRACE("(%d)\n", count );
1444
1445     if (count < 20) count = 20;  /* No point in going below 20 */
1446     else if (count > 254) count = 254;
1447
1448     if (count == 20)
1449     {
1450         if (pdb->nbFiles > 20)
1451         {
1452             memcpy( pdb->fileHandles, files, 20 );
1453             GlobalFree16( pdb->hFileHandles );
1454             pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18,
1455                                                    GlobalHandleToSel16( hPDB ) );
1456             pdb->hFileHandles = 0;
1457             pdb->nbFiles = 20;
1458         }
1459     }
1460     else  /* More than 20, need a new file handles table */
1461     {
1462         BYTE *newfiles;
1463         HGLOBAL16 newhandle = GlobalAlloc16( GMEM_MOVEABLE, count );
1464         if (!newhandle)
1465         {
1466             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1467             return pdb->nbFiles;
1468         }
1469         newfiles = (BYTE *)GlobalLock16( newhandle );
1470
1471         if (count > pdb->nbFiles)
1472         {
1473             memcpy( newfiles, files, pdb->nbFiles );
1474             memset( newfiles + pdb->nbFiles, 0xff, count - pdb->nbFiles );
1475         }
1476         else memcpy( newfiles, files, count );
1477         if (pdb->nbFiles > 20) GlobalFree16( pdb->hFileHandles );
1478         pdb->fileHandlesPtr = WIN16_GlobalLock16( newhandle );
1479         pdb->hFileHandles   = newhandle;
1480         pdb->nbFiles = count;
1481     }
1482     return pdb->nbFiles;
1483 }
1484
1485
1486 /*************************************************************************
1487  *           SetHandleCount32   (KERNEL32.494)
1488  */
1489 UINT WINAPI SetHandleCount( UINT count )
1490 {
1491     return MIN( 256, count );
1492 }
1493
1494
1495 /***********************************************************************
1496  *           FlushFileBuffers   (KERNEL32.133)
1497  */
1498 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
1499 {
1500     struct flush_file_request *req = get_req_buffer();
1501     req->handle = hFile;
1502     return !server_call( REQ_FLUSH_FILE );
1503 }
1504
1505
1506 /**************************************************************************
1507  *           SetEndOfFile   (KERNEL32.483)
1508  */
1509 BOOL WINAPI SetEndOfFile( HANDLE hFile )
1510 {
1511     struct truncate_file_request *req = get_req_buffer();
1512     req->handle = hFile;
1513     return !server_call( REQ_TRUNCATE_FILE );
1514 }
1515
1516
1517 /***********************************************************************
1518  *           DeleteFile16   (KERNEL.146)
1519  */
1520 BOOL16 WINAPI DeleteFile16( LPCSTR path )
1521 {
1522     return DeleteFileA( path );
1523 }
1524
1525
1526 /***********************************************************************
1527  *           DeleteFile32A   (KERNEL32.71)
1528  */
1529 BOOL WINAPI DeleteFileA( LPCSTR path )
1530 {
1531     DOS_FULL_NAME full_name;
1532
1533     TRACE("'%s'\n", path );
1534
1535     if (!*path)
1536     {
1537         ERR("Empty path passed\n");
1538         return FALSE;
1539     }
1540     if (DOSFS_GetDevice( path ))
1541     {
1542         WARN("cannot remove DOS device '%s'!\n", path);
1543         SetLastError( ERROR_FILE_NOT_FOUND );
1544         return FALSE;
1545     }
1546
1547     if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
1548     if (unlink( full_name.long_name ) == -1)
1549     {
1550         FILE_SetDosError();
1551         return FALSE;
1552     }
1553     return TRUE;
1554 }
1555
1556
1557 /***********************************************************************
1558  *           DeleteFile32W   (KERNEL32.72)
1559  */
1560 BOOL WINAPI DeleteFileW( LPCWSTR path )
1561 {
1562     LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1563     BOOL ret = DeleteFileA( xpath );
1564     HeapFree( GetProcessHeap(), 0, xpath );
1565     return ret;
1566 }
1567
1568
1569 /***********************************************************************
1570  *           FILE_dommap
1571  */
1572 LPVOID FILE_dommap( int unix_handle, LPVOID start,
1573                     DWORD size_high, DWORD size_low,
1574                     DWORD offset_high, DWORD offset_low,
1575                     int prot, int flags )
1576 {
1577     int fd = -1;
1578     int pos;
1579     LPVOID ret;
1580
1581     if (size_high || offset_high)
1582         FIXME("offsets larger than 4Gb not supported\n");
1583
1584     if (unix_handle == -1)
1585     {
1586 #ifdef MAP_ANON
1587         flags |= MAP_ANON;
1588 #else
1589         static int fdzero = -1;
1590
1591         if (fdzero == -1)
1592         {
1593             if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1)
1594             {
1595                 perror( "/dev/zero: open" );
1596                 exit(1);
1597             }
1598         }
1599         fd = fdzero;
1600 #endif  /* MAP_ANON */
1601         /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
1602 #ifdef MAP_SHARED
1603         flags &= ~MAP_SHARED;
1604 #endif
1605 #ifdef MAP_PRIVATE
1606         flags |= MAP_PRIVATE;
1607 #endif
1608     }
1609     else fd = unix_handle;
1610
1611     if ((ret = mmap( start, size_low, prot,
1612                      flags, fd, offset_low )) != (LPVOID)-1)
1613         return ret;
1614
1615     /* mmap() failed; if this is because the file offset is not    */
1616     /* page-aligned (EINVAL), or because the underlying filesystem */
1617     /* does not support mmap() (ENOEXEC), we do it by hand.        */
1618
1619     if (unix_handle == -1) return ret;
1620     if ((errno != ENOEXEC) && (errno != EINVAL)) return ret;
1621     if (prot & PROT_WRITE)
1622     {
1623         /* We cannot fake shared write mappings */
1624 #ifdef MAP_SHARED
1625         if (flags & MAP_SHARED) return ret;
1626 #endif
1627 #ifdef MAP_PRIVATE
1628         if (!(flags & MAP_PRIVATE)) return ret;
1629 #endif
1630     }
1631 /*    printf( "FILE_mmap: mmap failed (%d), faking it\n", errno );*/
1632     /* Reserve the memory with an anonymous mmap */
1633     ret = FILE_dommap( -1, start, size_high, size_low, 0, 0,
1634                        PROT_READ | PROT_WRITE, flags );
1635     if (ret == (LPVOID)-1) return ret;
1636     /* Now read in the file */
1637     if ((pos = lseek( fd, offset_low, SEEK_SET )) == -1)
1638     {
1639         FILE_munmap( ret, size_high, size_low );
1640         return (LPVOID)-1;
1641     }
1642     read( fd, ret, size_low );
1643     lseek( fd, pos, SEEK_SET );  /* Restore the file pointer */
1644     mprotect( ret, size_low, prot );  /* Set the right protection */
1645     return ret;
1646 }
1647
1648
1649 /***********************************************************************
1650  *           FILE_munmap
1651  */
1652 int FILE_munmap( LPVOID start, DWORD size_high, DWORD size_low )
1653 {
1654     if (size_high)
1655       FIXME("offsets larger than 4Gb not supported\n");
1656     return munmap( start, size_low );
1657 }
1658
1659
1660 /***********************************************************************
1661  *           GetFileType   (KERNEL32.222)
1662  */
1663 DWORD WINAPI GetFileType( HANDLE hFile )
1664 {
1665     struct get_file_info_request *req = get_req_buffer();
1666     req->handle = hFile;
1667     if (server_call( REQ_GET_FILE_INFO )) return FILE_TYPE_UNKNOWN;
1668     return req->type;
1669 }
1670
1671
1672 /**************************************************************************
1673  *           MoveFileExA   (KERNEL32.???)
1674  */
1675 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
1676 {
1677     DOS_FULL_NAME full_name1, full_name2;
1678
1679     TRACE("(%s,%s,%04lx)\n", fn1, fn2, flag);
1680
1681     if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
1682
1683     if (fn2)  /* !fn2 means delete fn1 */
1684     {
1685         if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
1686         {
1687             /* target exists, check if we may overwrite */
1688             if (!(flag & MOVEFILE_REPLACE_EXISTING))
1689             {
1690                 /* FIXME: Use right error code */
1691                 SetLastError( ERROR_ACCESS_DENIED );
1692                 return FALSE;
1693             }
1694         }
1695         else if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
1696
1697         /* Source name and target path are valid */
1698
1699         if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1700         {
1701             /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
1702                Perhaps we should queue these command and execute it
1703                when exiting... What about using on_exit(2)
1704             */
1705             FIXME("Please move existing file '%s' to file '%s' when Wine has finished\n",
1706                   full_name1.long_name, full_name2.long_name);
1707             return TRUE;
1708         }
1709
1710         if (full_name1.drive != full_name2.drive)
1711         {
1712             /* use copy, if allowed */
1713             if (!(flag & MOVEFILE_COPY_ALLOWED))
1714             {
1715                 /* FIXME: Use right error code */
1716                 SetLastError( ERROR_FILE_EXISTS );
1717                 return FALSE;
1718             }
1719             return CopyFileA( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) );
1720         }
1721         if (rename( full_name1.long_name, full_name2.long_name ) == -1)
1722         {
1723             FILE_SetDosError();
1724             return FALSE;
1725         }
1726         return TRUE;
1727     }
1728     else /* fn2 == NULL means delete source */
1729     {
1730         if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1731         {
1732             if (flag & MOVEFILE_COPY_ALLOWED) {
1733                 WARN("Illegal flag\n");
1734                 SetLastError( ERROR_GEN_FAILURE );
1735                 return FALSE;
1736             }
1737             /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
1738                Perhaps we should queue these command and execute it
1739                when exiting... What about using on_exit(2)
1740             */
1741             FIXME("Please delete file '%s' when Wine has finished\n",
1742                   full_name1.long_name);
1743             return TRUE;
1744         }
1745
1746         if (unlink( full_name1.long_name ) == -1)
1747         {
1748             FILE_SetDosError();
1749             return FALSE;
1750         }
1751         return TRUE; /* successfully deleted */
1752     }
1753 }
1754
1755 /**************************************************************************
1756  *           MoveFileEx32W   (KERNEL32.???)
1757  */
1758 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
1759 {
1760     LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
1761     LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
1762     BOOL res = MoveFileExA( afn1, afn2, flag );
1763     HeapFree( GetProcessHeap(), 0, afn1 );
1764     HeapFree( GetProcessHeap(), 0, afn2 );
1765     return res;
1766 }
1767
1768
1769 /**************************************************************************
1770  *           MoveFile32A   (KERNEL32.387)
1771  *
1772  *  Move file or directory
1773  */
1774 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
1775 {
1776     DOS_FULL_NAME full_name1, full_name2;
1777     struct stat fstat;
1778
1779     TRACE("(%s,%s)\n", fn1, fn2 );
1780
1781     if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
1782     if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
1783       /* The new name must not already exist */
1784       return FALSE;
1785     if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
1786
1787     if (full_name1.drive == full_name2.drive) /* move */
1788     if (rename( full_name1.long_name, full_name2.long_name ) == -1)
1789     {
1790         FILE_SetDosError();
1791         return FALSE;
1792     }
1793       else return TRUE;
1794     else /*copy */ {
1795       if (stat(  full_name1.long_name, &fstat ))
1796         {
1797           WARN("Invalid source file %s\n",
1798                         full_name1.long_name);
1799           FILE_SetDosError();
1800           return FALSE;
1801         }
1802       if (S_ISDIR(fstat.st_mode)) {
1803         /* No Move for directories across file systems */
1804         /* FIXME: Use right error code */
1805         SetLastError( ERROR_GEN_FAILURE );
1806         return FALSE;
1807       }
1808       else
1809         return CopyFileA(fn1, fn2, TRUE); /*fail, if exist */
1810     }
1811 }
1812
1813
1814 /**************************************************************************
1815  *           MoveFile32W   (KERNEL32.390)
1816  */
1817 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
1818 {
1819     LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
1820     LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
1821     BOOL res = MoveFileA( afn1, afn2 );
1822     HeapFree( GetProcessHeap(), 0, afn1 );
1823     HeapFree( GetProcessHeap(), 0, afn2 );
1824     return res;
1825 }
1826
1827
1828 /**************************************************************************
1829  *           CopyFile32A   (KERNEL32.36)
1830  */
1831 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists )
1832 {
1833     HFILE h1, h2;
1834     BY_HANDLE_FILE_INFORMATION info;
1835     UINT count;
1836     BOOL ret = FALSE;
1837     int mode;
1838     char buffer[2048];
1839
1840     if ((h1 = _lopen( source, OF_READ )) == HFILE_ERROR) return FALSE;
1841     if (!GetFileInformationByHandle( h1, &info ))
1842     {
1843         CloseHandle( h1 );
1844         return FALSE;
1845     }
1846     mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
1847     if ((h2 = CreateFileA( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1848                              fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
1849                              info.dwFileAttributes, h1 )) == HFILE_ERROR)
1850     {
1851         CloseHandle( h1 );
1852         return FALSE;
1853     }
1854     while ((count = _lread( h1, buffer, sizeof(buffer) )) > 0)
1855     {
1856         char *p = buffer;
1857         while (count > 0)
1858         {
1859             INT res = _lwrite( h2, p, count );
1860             if (res <= 0) goto done;
1861             p += res;
1862             count -= res;
1863         }
1864     }
1865     ret =  TRUE;
1866 done:
1867     CloseHandle( h1 );
1868     CloseHandle( h2 );
1869     return ret;
1870 }
1871
1872
1873 /**************************************************************************
1874  *           CopyFile32W   (KERNEL32.37)
1875  */
1876 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists)
1877 {
1878     LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
1879     LPSTR destA   = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
1880     BOOL ret = CopyFileA( sourceA, destA, fail_if_exists );
1881     HeapFree( GetProcessHeap(), 0, sourceA );
1882     HeapFree( GetProcessHeap(), 0, destA );
1883     return ret;
1884 }
1885
1886
1887 /**************************************************************************
1888  *           CopyFileEx32A   (KERNEL32.858)
1889  *
1890  * This implementation ignores most of the extra parameters passed-in into
1891  * the "ex" version of the method and calls the CopyFile method.
1892  * It will have to be fixed eventually.
1893  */
1894 BOOL WINAPI CopyFileExA(LPCSTR             sourceFilename,
1895                            LPCSTR             destFilename,
1896                            LPPROGRESS_ROUTINE progressRoutine,
1897                            LPVOID             appData,
1898                            LPBOOL           cancelFlagPointer,
1899                            DWORD              copyFlags)
1900 {
1901   BOOL failIfExists = FALSE;
1902
1903   /*
1904    * Interpret the only flag that CopyFile can interpret.
1905    */
1906   if ( (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0)
1907   {
1908     failIfExists = TRUE;
1909   }
1910
1911   return CopyFileA(sourceFilename, destFilename, failIfExists);
1912 }
1913
1914 /**************************************************************************
1915  *           CopyFileEx32W   (KERNEL32.859)
1916  */
1917 BOOL WINAPI CopyFileExW(LPCWSTR            sourceFilename,
1918                            LPCWSTR            destFilename,
1919                            LPPROGRESS_ROUTINE progressRoutine,
1920                            LPVOID             appData,
1921                            LPBOOL           cancelFlagPointer,
1922                            DWORD              copyFlags)
1923 {
1924     LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, sourceFilename );
1925     LPSTR destA   = HEAP_strdupWtoA( GetProcessHeap(), 0, destFilename );
1926
1927     BOOL ret = CopyFileExA(sourceA,
1928                               destA,
1929                               progressRoutine,
1930                               appData,
1931                               cancelFlagPointer,
1932                               copyFlags);
1933
1934     HeapFree( GetProcessHeap(), 0, sourceA );
1935     HeapFree( GetProcessHeap(), 0, destA );
1936
1937     return ret;
1938 }
1939
1940
1941 /***********************************************************************
1942  *              SetFileTime   (KERNEL32.650)
1943  */
1944 BOOL WINAPI SetFileTime( HANDLE hFile,
1945                            const FILETIME *lpCreationTime,
1946                            const FILETIME *lpLastAccessTime,
1947                            const FILETIME *lpLastWriteTime )
1948 {
1949     struct set_file_time_request *req = get_req_buffer();
1950
1951     req->handle = hFile;
1952     if (lpLastAccessTime)
1953         req->access_time = DOSFS_FileTimeToUnixTime(lpLastAccessTime, NULL);
1954     else
1955         req->access_time = 0; /* FIXME */
1956     if (lpLastWriteTime)
1957         req->write_time = DOSFS_FileTimeToUnixTime(lpLastWriteTime, NULL);
1958     else
1959         req->write_time = 0; /* FIXME */
1960     return !server_call( REQ_SET_FILE_TIME );
1961 }
1962
1963
1964 /**************************************************************************
1965  *           LockFile   (KERNEL32.511)
1966  */
1967 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
1968                         DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
1969 {
1970     struct lock_file_request *req = get_req_buffer();
1971
1972     req->handle      = hFile;
1973     req->offset_low  = dwFileOffsetLow;
1974     req->offset_high = dwFileOffsetHigh;
1975     req->count_low   = nNumberOfBytesToLockLow;
1976     req->count_high  = nNumberOfBytesToLockHigh;
1977     return !server_call( REQ_LOCK_FILE );
1978 }
1979
1980 /**************************************************************************
1981  * LockFileEx [KERNEL32.512]
1982  *
1983  * Locks a byte range within an open file for shared or exclusive access.
1984  *
1985  * RETURNS
1986  *   success: TRUE
1987  *   failure: FALSE
1988  * NOTES
1989  *
1990  * Per Microsoft docs, the third parameter (reserved) must be set to 0.
1991  */
1992 BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
1993                       DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
1994                       LPOVERLAPPED pOverlapped )
1995 {
1996     FIXME("hFile=%d,flags=%ld,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
1997           hFile, flags, reserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh,
1998           pOverlapped);
1999     if (reserved == 0)
2000         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2001     else
2002     {
2003         ERR("reserved == %ld: Supposed to be 0??\n", reserved);
2004         SetLastError(ERROR_INVALID_PARAMETER);
2005     }
2006
2007     return FALSE;
2008 }
2009
2010
2011 /**************************************************************************
2012  *           UnlockFile   (KERNEL32.703)
2013  */
2014 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
2015                           DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
2016 {
2017     struct unlock_file_request *req = get_req_buffer();
2018
2019     req->handle      = hFile;
2020     req->offset_low  = dwFileOffsetLow;
2021     req->offset_high = dwFileOffsetHigh;
2022     req->count_low   = nNumberOfBytesToUnlockLow;
2023     req->count_high  = nNumberOfBytesToUnlockHigh;
2024     return !server_call( REQ_UNLOCK_FILE );
2025 }
2026
2027
2028 /**************************************************************************
2029  *           UnlockFileEx   (KERNEL32.705)
2030  */
2031 BOOL WINAPI UnlockFileEx(
2032                 HFILE hFile,
2033                 DWORD dwReserved,
2034                 DWORD nNumberOfBytesToUnlockLow,
2035                 DWORD nNumberOfBytesToUnlockHigh,
2036                 LPOVERLAPPED lpOverlapped
2037 )
2038 {
2039         FIXME("hFile=%d,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
2040           hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh,
2041           lpOverlapped);
2042         if (dwReserved == 0)
2043                 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2044         else
2045         {
2046                 ERR("reserved == %ld: Supposed to be 0??\n", dwReserved);
2047                 SetLastError(ERROR_INVALID_PARAMETER);
2048         }
2049
2050         return FALSE;
2051 }
2052
2053
2054 #if 0
2055
2056 struct DOS_FILE_LOCK {
2057   struct DOS_FILE_LOCK *        next;
2058   DWORD                         base;
2059   DWORD                         len;
2060   DWORD                         processId;
2061   FILE_OBJECT *                 dos_file;
2062 /*  char *                      unix_name;*/
2063 };
2064
2065 typedef struct DOS_FILE_LOCK DOS_FILE_LOCK;
2066
2067 static DOS_FILE_LOCK *locks = NULL;
2068 static void DOS_RemoveFileLocks(FILE_OBJECT *file);
2069
2070
2071 /* Locks need to be mirrored because unix file locking is based
2072  * on the pid. Inside of wine there can be multiple WINE processes
2073  * that share the same unix pid.
2074  * Read's and writes should check these locks also - not sure
2075  * how critical that is at this point (FIXME).
2076  */
2077
2078 static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
2079 {
2080   DOS_FILE_LOCK *curr;
2081   DWORD         processId;
2082
2083   processId = GetCurrentProcessId();
2084
2085   /* check if lock overlaps a current lock for the same file */
2086 #if 0
2087   for (curr = locks; curr; curr = curr->next) {
2088     if (strcmp(curr->unix_name, file->unix_name) == 0) {
2089       if ((f->l_start == curr->base) && (f->l_len == curr->len))
2090         return TRUE;/* region is identic */
2091       if ((f->l_start < (curr->base + curr->len)) &&
2092           ((f->l_start + f->l_len) > curr->base)) {
2093         /* region overlaps */
2094         return FALSE;
2095       }
2096     }
2097   }
2098 #endif
2099
2100   curr = HeapAlloc( GetProcessHeap(), 0, sizeof(DOS_FILE_LOCK) );
2101   curr->processId = GetCurrentProcessId();
2102   curr->base = f->l_start;
2103   curr->len = f->l_len;
2104 /*  curr->unix_name = HEAP_strdupA( GetProcessHeap(), 0, file->unix_name);*/
2105   curr->next = locks;
2106   curr->dos_file = file;
2107   locks = curr;
2108   return TRUE;
2109 }
2110
2111 static void DOS_RemoveFileLocks(FILE_OBJECT *file)
2112 {
2113   DWORD         processId;
2114   DOS_FILE_LOCK **curr;
2115   DOS_FILE_LOCK *rem;
2116
2117   processId = GetCurrentProcessId();
2118   curr = &locks;
2119   while (*curr) {
2120     if ((*curr)->dos_file == file) {
2121       rem = *curr;
2122       *curr = (*curr)->next;
2123 /*      HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2124       HeapFree( GetProcessHeap(), 0, rem );
2125     }
2126     else
2127       curr = &(*curr)->next;
2128   }
2129 }
2130
2131 static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
2132 {
2133   DWORD         processId;
2134   DOS_FILE_LOCK **curr;
2135   DOS_FILE_LOCK *rem;
2136
2137   processId = GetCurrentProcessId();
2138   for (curr = &locks; *curr; curr = &(*curr)->next) {
2139     if ((*curr)->processId == processId &&
2140         (*curr)->dos_file == file &&
2141         (*curr)->base == f->l_start &&
2142         (*curr)->len == f->l_len) {
2143       /* this is the same lock */
2144       rem = *curr;
2145       *curr = (*curr)->next;
2146 /*      HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2147       HeapFree( GetProcessHeap(), 0, rem );
2148       return TRUE;
2149     }
2150   }
2151   /* no matching lock found */
2152   return FALSE;
2153 }
2154
2155
2156 /**************************************************************************
2157  *           LockFile   (KERNEL32.511)
2158  */
2159 BOOL WINAPI LockFile(
2160         HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2161         DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
2162 {
2163   struct flock f;
2164   FILE_OBJECT *file;
2165
2166   TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2167                hFile, dwFileOffsetLow, dwFileOffsetHigh,
2168                nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh);
2169
2170   if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) {
2171     FIXME("Unimplemented bytes > 32bits\n");
2172     return FALSE;
2173   }
2174
2175   f.l_start = dwFileOffsetLow;
2176   f.l_len = nNumberOfBytesToLockLow;
2177   f.l_whence = SEEK_SET;
2178   f.l_pid = 0;
2179   f.l_type = F_WRLCK;
2180
2181   if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2182
2183   /* shadow locks internally */
2184   if (!DOS_AddLock(file, &f)) {
2185     SetLastError( ERROR_LOCK_VIOLATION );
2186     return FALSE;
2187   }
2188
2189   /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2190 #ifdef USE_UNIX_LOCKS
2191   if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2192     if (errno == EACCES || errno == EAGAIN) {
2193       SetLastError( ERROR_LOCK_VIOLATION );
2194     }
2195     else {
2196       FILE_SetDosError();
2197     }
2198     /* remove our internal copy of the lock */
2199     DOS_RemoveLock(file, &f);
2200     return FALSE;
2201   }
2202 #endif
2203   return TRUE;
2204 }
2205
2206
2207 /**************************************************************************
2208  *           UnlockFile   (KERNEL32.703)
2209  */
2210 BOOL WINAPI UnlockFile(
2211         HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2212         DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
2213 {
2214   FILE_OBJECT *file;
2215   struct flock f;
2216
2217   TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2218                hFile, dwFileOffsetLow, dwFileOffsetHigh,
2219                nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);
2220
2221   if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) {
2222     WARN("Unimplemented bytes > 32bits\n");
2223     return FALSE;
2224   }
2225
2226   f.l_start = dwFileOffsetLow;
2227   f.l_len = nNumberOfBytesToUnlockLow;
2228   f.l_whence = SEEK_SET;
2229   f.l_pid = 0;
2230   f.l_type = F_UNLCK;
2231
2232   if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2233
2234   DOS_RemoveLock(file, &f);     /* ok if fails - may be another wine */
2235
2236   /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2237 #ifdef USE_UNIX_LOCKS
2238   if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2239     FILE_SetDosError();
2240     return FALSE;
2241   }
2242 #endif
2243   return TRUE;
2244 }
2245 #endif
2246
2247 /**************************************************************************
2248  * GetFileAttributesEx32A [KERNEL32.874]
2249  */
2250 BOOL WINAPI GetFileAttributesExA(
2251         LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2252         LPVOID lpFileInformation)
2253 {
2254     DOS_FULL_NAME full_name;
2255     BY_HANDLE_FILE_INFORMATION info;
2256
2257     if (lpFileName == NULL) return FALSE;
2258     if (lpFileInformation == NULL) return FALSE;
2259
2260     if (fInfoLevelId == GetFileExInfoStandard) {
2261         LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
2262             (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
2263         if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
2264         if (!FILE_Stat( full_name.long_name, &info )) return FALSE;
2265
2266         lpFad->dwFileAttributes = info.dwFileAttributes;
2267         lpFad->ftCreationTime   = info.ftCreationTime;
2268         lpFad->ftLastAccessTime = info.ftLastAccessTime;
2269         lpFad->ftLastWriteTime  = info.ftLastWriteTime;
2270         lpFad->nFileSizeHigh    = info.nFileSizeHigh;
2271         lpFad->nFileSizeLow     = info.nFileSizeLow;
2272     }
2273     else {
2274         FIXME("invalid info level %d!\n", fInfoLevelId);
2275         return FALSE;
2276     }
2277
2278     return TRUE;
2279 }
2280
2281
2282 /**************************************************************************
2283  * GetFileAttributesEx32W [KERNEL32.875]
2284  */
2285 BOOL WINAPI GetFileAttributesExW(
2286         LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2287         LPVOID lpFileInformation)
2288 {
2289     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
2290     BOOL res =
2291         GetFileAttributesExA( nameA, fInfoLevelId, lpFileInformation);
2292     HeapFree( GetProcessHeap(), 0, nameA );
2293     return res;
2294 }