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