files/file.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include <assert.h>
   9 #include <ctype.h>
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/errno.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/mman.h>
  19 #include <time.h>
  20 #include <unistd.h>
  21 #include <utime.h>
  22
  23 #include "windows.h"
  24 #include "winerror.h"
  25 #include "drive.h"
  26 #include "file.h"
  27 #include "global.h"
  28 #include "heap.h"
  29 #include "msdos.h"
  30 #include "options.h"
  31 #include "ldt.h"
  32 #include "process.h"
  33 #include "task.h"
  34 #include "stddebug.h"
  35 #include "debug.h"
  36
  37 #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
  38 #define MAP_ANON MAP_ANONYMOUS
  39 #endif
  40
  41
  42 /***********************************************************************
  43  *           FILE_Alloc
  44  *
  45  * Allocate a file.
  46  */
  47 static HFILE32 FILE_Alloc( FILE_OBJECT **file )
  48 {
  49     HFILE32 handle;
  50     *file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) );
  51     if (!*file)
  52     {
  53         DOS_ERROR( ER_TooManyOpenFiles, EC_ProgramError, SA_Abort, EL_Disk );
  54         return NULL;
  55     }
  56     (*file)->header.type = K32OBJ_FILE;
  57     (*file)->header.refcount = 0;
  58     (*file)->unix_handle = -1;
  59     (*file)->unix_name = NULL;
  60     (*file)->type = FILE_TYPE_DISK;
  61
  62     handle = PROCESS_AllocHandle( &(*file)->header, 0 );
  63     if (handle == INVALID_HANDLE_VALUE32) *file = NULL;
  64     return handle;
  65 }
  66
  67
  68 /***********************************************************************
  69  *           FILE_Destroy
  70  *
  71  * Destroy a DOS file.
  72  */
  73 void FILE_Destroy( K32OBJ *ptr )
  74 {
  75     FILE_OBJECT *file = (FILE_OBJECT *)ptr;
  76     assert( ptr->type == K32OBJ_FILE );
  77
  78     if (file->unix_handle != -1) close( file->unix_handle );
  79     if (file->unix_name) HeapFree( SystemHeap, 0, file->unix_name );
  80     ptr->type = K32OBJ_UNKNOWN;
  81     HeapFree( SystemHeap, 0, file );
  82 }
  83
  84
  85 /***********************************************************************
  86  *           FILE_GetFile
  87  *
  88  * Return the DOS file associated to a task file handle. FILE_ReleaseFile must
  89  * be called to release the file.
  90  */
  91 static FILE_OBJECT *FILE_GetFile( HFILE32 handle )
  92 {
  93     return (FILE_OBJECT *)PROCESS_GetObjPtr( handle, K32OBJ_FILE );
  94 }
  95
  96
  97 /***********************************************************************
  98  *           FILE_ReleaseFile
  99  *
 100  * Release a DOS file obtained with FILE_GetFile.
 101  */
 102 static void FILE_ReleaseFile( FILE_OBJECT *file )
 103 {
 104     K32OBJ_DecCount( &file->header );
 105 }
 106
 107
 108 /***********************************************************************
 109  *           FILE_GetUnixHandle
 110  *
 111  * Return the Unix handle associated to a file handle.
 112  */
 113 int FILE_GetUnixHandle( HFILE32 hFile )
 114 {
 115     FILE_OBJECT *file;
 116     int ret;
 117
 118     if (!(file = FILE_GetFile( hFile ))) return -1;
 119     ret = file->unix_handle;
 120     FILE_ReleaseFile( file );
 121     return ret;
 122 }
 123
 124
 125 /***********************************************************************
 126  *           FILE_SetDosError
 127  *
 128  * Set the DOS error code from errno.
 129  */
 130 void FILE_SetDosError(void)
 131 {
 132     dprintf_file(stddeb, "FILE_SetDosError: errno = %d\n", errno );
 133     switch (errno)
 134     {
 135     case EAGAIN:
 136         DOS_ERROR( ER_ShareViolation, EC_Temporary, SA_Retry, EL_Disk );
 137         break;
 138     case EBADF:
 139         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
 140         break;
 141     case ENOSPC:
 142         DOS_ERROR( ER_DiskFull, EC_MediaError, SA_Abort, EL_Disk );
 143         break;
 144     case EACCES:
 145     case EPERM:
 146     case EROFS:
 147         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 148         break;
 149     case EBUSY:
 150         DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Abort, EL_Disk );
 151         break;
 152     case ENOENT:
 153         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 154         break;
 155     case EISDIR:
 156         DOS_ERROR( ER_CanNotMakeDir, EC_AccessDenied, SA_Abort, EL_Unknown );
 157         break;
 158     case ENFILE:
 159     case EMFILE:
 160         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Unknown );
 161         break;
 162     case EEXIST:
 163         DOS_ERROR( ER_FileExists, EC_Exists, SA_Abort, EL_Disk );
 164         break;
 165     default:
 166         perror( "int21: unknown errno" );
 167         DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, EL_Unknown );
 168         break;
 169     }
 170 }
 171
 172
 173 /***********************************************************************
 174  *           FILE_DupUnixHandle
 175  *
 176  * Duplicate a Unix handle into a task handle.
 177  */
 178 HFILE32 FILE_DupUnixHandle( int fd )
 179 {
 180     HFILE32 handle;
 181     FILE_OBJECT *file;
 182
 183     if ((handle = FILE_Alloc( &file )) != INVALID_HANDLE_VALUE32)
 184     {
 185         if ((file->unix_handle = dup(fd)) == -1)
 186         {
 187             FILE_SetDosError();
 188             CloseHandle( handle );
 189             return INVALID_HANDLE_VALUE32;
 190         }
 191     }
 192     return handle;
 193 }
 194
 195
 196 /***********************************************************************
 197  *           FILE_OpenUnixFile
 198  */
 199 static HFILE32 FILE_OpenUnixFile( const char *name, int mode )
 200 {
 201     HFILE32 handle;
 202     FILE_OBJECT *file;
 203     struct stat st;
 204
 205     if ((handle = FILE_Alloc( &file )) == INVALID_HANDLE_VALUE32)
 206         return INVALID_HANDLE_VALUE32;
 207
 208     if ((file->unix_handle = open( name, mode, 0666 )) == -1)
 209     {
 210         if (!Options.failReadOnly && (mode == O_RDWR))
 211             file->unix_handle = open( name, O_RDONLY );
 212     }
 213     if ((file->unix_handle == -1) || (fstat( file->unix_handle, &st ) == -1))
 214     {
 215         FILE_SetDosError();
 216         CloseHandle( handle );
 217         return INVALID_HANDLE_VALUE32;
 218     }
 219     if (S_ISDIR(st.st_mode))
 220     {
 221         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 222         CloseHandle( handle );
 223         return INVALID_HANDLE_VALUE32;
 224     }
 225
 226     /* File opened OK, now fill the FILE_OBJECT */
 227
 228     file->unix_name = HEAP_strdupA( SystemHeap, 0, name );
 229     return handle;
 230 }
 231
 232
 233 /***********************************************************************
 234  *           FILE_Open
 235  */
 236 HFILE32 FILE_Open( LPCSTR path, INT32 mode )
 237 {
 238     DOS_FULL_NAME full_name;
 239     const char *unixName;
 240
 241     dprintf_file(stddeb, "FILE_Open: '%s' %04x\n", path, mode );
 242     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 243     {
 244         dprintf_file( stddeb, "FILE_Open: opening device '%s'\n", unixName );
 245         if (!unixName[0])  /* Non-existing device */
 246         {
 247             dprintf_file(stddeb, "FILE_Open: Non-existing device\n");
 248             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 249             return HFILE_ERROR32;
 250         }
 251     }
 252     else /* check for filename, don't check for last entry if creating */
 253     {
 254         if (!DOSFS_GetFullName( path, !(mode & O_CREAT), &full_name ))
 255             return HFILE_ERROR32;
 256         unixName = full_name.long_name;
 257     }
 258     return FILE_OpenUnixFile( unixName, mode );
 259 }
 260
 261
 262 /***********************************************************************
 263  *           FILE_Create
 264  */
 265 static HFILE32 FILE_Create( LPCSTR path, int mode, int unique )
 266 {
 267     HFILE32 handle;
 268     FILE_OBJECT *file;
 269     const char *unixName;
 270     DOS_FULL_NAME full_name;
 271
 272     dprintf_file(stddeb, "FILE_Create: '%s' %04x %d\n", path, mode, unique );
 273
 274     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 275     {
 276         dprintf_file(stddeb, "FILE_Create: creating device '%s'!\n", unixName);
 277         DOS_ERROR( ER_AccessDenied, EC_NotFound, SA_Abort, EL_Disk );
 278         return INVALID_HANDLE_VALUE32;
 279     }
 280
 281     if ((handle = FILE_Alloc( &file )) == INVALID_HANDLE_VALUE32)
 282         return INVALID_HANDLE_VALUE32;
 283
 284     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
 285     {
 286         CloseHandle( handle );
 287         return INVALID_HANDLE_VALUE32;
 288     }
 289     if ((file->unix_handle = open( full_name.long_name,
 290                            O_CREAT | O_TRUNC | O_RDWR | (unique ? O_EXCL : 0),
 291                            mode )) == -1)
 292     {
 293         FILE_SetDosError();
 294         CloseHandle( handle );
 295         return INVALID_HANDLE_VALUE32;
 296     }
 297
 298     /* File created OK, now fill the FILE_OBJECT */
 299
 300     file->unix_name = HEAP_strdupA( SystemHeap, 0, full_name.long_name );
 301     return handle;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           FILE_FillInfo
 307  *
 308  * Fill a file information from a struct stat.
 309  */
 310 static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
 311 {
 312     if (S_ISDIR(st->st_mode))
 313         info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 314     else
 315         info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
 316     if (!(st->st_mode & S_IWUSR))
 317         info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
 318
 319     DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftCreationTime, 0 );
 320     DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftLastWriteTime, 0 );
 321     DOSFS_UnixTimeToFileTime( st->st_atime, &info->ftLastAccessTime, 0 );
 322
 323     info->dwVolumeSerialNumber = 0;  /* FIXME */
 324     info->nFileSizeHigh = 0;
 325     info->nFileSizeLow  = S_ISDIR(st->st_mode) ? 0 : st->st_size;
 326     info->nNumberOfLinks = st->st_nlink;
 327     info->nFileIndexHigh = 0;
 328     info->nFileIndexLow  = st->st_ino;
 329 }
 330
 331
 332 /***********************************************************************
 333  *           FILE_Stat
 334  *
 335  * Stat a Unix path name. Return TRUE if OK.
 336  */
 337 BOOL32 FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
 338 {
 339     struct stat st;
 340
 341     if (stat( unixName, &st ) == -1)
 342     {
 343         FILE_SetDosError();
 344         return FALSE;
 345     }
 346     FILE_FillInfo( &st, info );
 347     return TRUE;
 348 }
 349
 350
 351 /***********************************************************************
 352  *             GetFileInformationByHandle   (KERNEL32.219)
 353  */
 354 DWORD GetFileInformationByHandle( HFILE32 hFile,
 355                                   BY_HANDLE_FILE_INFORMATION *info )
 356 {
 357     FILE_OBJECT *file;
 358     DWORD ret = 0;
 359     struct stat st;
 360
 361     if (!(file = FILE_GetFile( hFile ))) return 0;
 362     if (fstat( file->unix_handle, &st ) == -1) FILE_SetDosError();
 363     else
 364     {
 365         FILE_FillInfo( &st, info );
 366         ret = 1;
 367     }
 368     FILE_ReleaseFile( file );
 369     return ret;
 370 }
 371
 372
 373 /**************************************************************************
 374  *           GetFileAttributes16   (KERNEL.420)
 375  */
 376 DWORD GetFileAttributes16( LPCSTR name )
 377 {
 378     return GetFileAttributes32A( name );
 379 }
 380
 381
 382 /**************************************************************************
 383  *           GetFileAttributes32A   (KERNEL32.217)
 384  */
 385 DWORD GetFileAttributes32A( LPCSTR name )
 386 {
 387     DOS_FULL_NAME full_name;
 388     BY_HANDLE_FILE_INFORMATION info;
 389
 390     if (!DOSFS_GetFullName( name, TRUE, &full_name )) return -1;
 391     if (!FILE_Stat( full_name.long_name, &info )) return -1;
 392     return info.dwFileAttributes;
 393 }
 394
 395
 396 /**************************************************************************
 397  *           GetFileAttributes32W   (KERNEL32.218)
 398  */
 399 DWORD GetFileAttributes32W( LPCWSTR name )
 400 {
 401     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 402     DWORD res = GetFileAttributes32A( nameA );
 403     HeapFree( GetProcessHeap(), 0, nameA );
 404     return res;
 405 }
 406
 407
 408 /***********************************************************************
 409  *           GetFileSize   (KERNEL32.220)
 410  */
 411 DWORD GetFileSize( HFILE32 hFile, LPDWORD filesizehigh )
 412 {
 413     BY_HANDLE_FILE_INFORMATION info;
 414     if (!GetFileInformationByHandle( hFile, &info )) return 0;
 415     if (filesizehigh) *filesizehigh = info.nFileSizeHigh;
 416     return info.nFileSizeLow;
 417 }
 418
 419
 420 /***********************************************************************
 421  *           GetFileTime   (KERNEL32.221)
 422  */
 423 BOOL32 GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime,
 424                     FILETIME *lpLastAccessTime, FILETIME *lpLastWriteTime )
 425 {
 426     BY_HANDLE_FILE_INFORMATION info;
 427     if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
 428     if (lpCreationTime)   *lpCreationTime   = info.ftCreationTime;
 429     if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
 430     if (lpLastWriteTime)  *lpLastWriteTime  = info.ftLastWriteTime;
 431     return TRUE;
 432 }
 433
 434 /***********************************************************************
 435  *           CompareFileTime   (KERNEL32.28)
 436  */
 437 INT32 CompareFileTime( LPFILETIME x, LPFILETIME y )
 438 {
 439         if (x->dwHighDateTime > y->dwHighDateTime)
 440                 return 1;
 441         if (x->dwHighDateTime < y->dwHighDateTime)
 442                 return -1;
 443         if (x->dwLowDateTime > y->dwLowDateTime)
 444                 return 1;
 445         if (x->dwLowDateTime < y->dwLowDateTime)
 446                 return -1;
 447         return 0;
 448 }
 449
 450 /***********************************************************************
 451  *           FILE_Dup
 452  *
 453  * dup() function for DOS handles.
 454  */
 455 HFILE32 FILE_Dup( HFILE32 hFile )
 456 {
 457     FILE_OBJECT *file;
 458     HFILE32 handle;
 459
 460     dprintf_file( stddeb, "FILE_Dup for handle %d\n", hFile );
 461     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR32;
 462     handle = PROCESS_AllocHandle( &file->header, 0 );
 463     FILE_ReleaseFile( file );
 464     dprintf_file( stddeb, "FILE_Dup return handle %d\n", handle );
 465     return handle;
 466 }
 467
 468
 469 /***********************************************************************
 470  *           FILE_Dup2
 471  *
 472  * dup2() function for DOS handles.
 473  */
 474 HFILE32 FILE_Dup2( HFILE32 hFile1, HFILE32 hFile2 )
 475 {
 476     FILE_OBJECT *file;
 477
 478     dprintf_file( stddeb, "FILE_Dup2 for handle %d\n", hFile1 );
 479     if (!(file = FILE_GetFile( hFile1 ))) return HFILE_ERROR32;
 480     if (!PROCESS_SetObjPtr( hFile2, &file->header, 0 )) hFile2 = HFILE_ERROR32;
 481     FILE_ReleaseFile( file );
 482     return hFile2;
 483 }
 484
 485
 486 /***********************************************************************
 487  *           GetTempFileName16   (KERNEL.97)
 488  */
 489 UINT16 GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
 490                           LPSTR buffer )
 491 {
 492     char temppath[144];
 493
 494     if ((drive & TF_FORCEDRIVE) &&
 495         !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
 496     {
 497         drive &= ~TF_FORCEDRIVE;
 498         fprintf( stderr, "Warning: GetTempFileName: invalid drive %d specified\n",
 499                  drive );
 500     }
 501
 502     if (drive & TF_FORCEDRIVE)
 503         sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
 504     else
 505     {
 506         GetTempPath32A( 132, temppath );
 507         strcat( temppath, "\\" );
 508     }
 509     return (UINT16)GetTempFileName32A( temppath, prefix, unique, buffer );
 510 }
 511
 512
 513 /***********************************************************************
 514  *           GetTempFileName32A   (KERNEL32.290)
 515  */
 516 UINT32 GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique,
 517                            LPSTR buffer)
 518 {
 519     DOS_FULL_NAME full_name;
 520     int i;
 521     LPSTR p;
 522     UINT32 num = unique ? (unique & 0xffff) : time(NULL) & 0xffff;
 523
 524     if (!path) return 0;
 525     strcpy( buffer, path );
 526     p = buffer + strlen(buffer);
 527     /* add a \, if there isn't one ... */
 528     if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
 529     *p++ = '~';
 530     for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
 531     sprintf( p, "%04x.tmp", num );
 532
 533     /* Now try to create it */
 534
 535     if (!unique)
 536     {
 537         do
 538         {
 539             HFILE32 handle = FILE_Create( buffer, 0666, TRUE );
 540             if (handle != INVALID_HANDLE_VALUE32)
 541             {  /* We created it */
 542                 dprintf_file( stddeb, "GetTempFileName32A: created %s\n",
 543                               buffer);
 544                 CloseHandle( handle );
 545                 break;
 546             }
 547             if (DOS_ExtendedError != ER_FileExists)
 548                 break;  /* No need to go on */
 549             num++;
 550             sprintf( p, "%04x.tmp", num );
 551         } while (num != (unique & 0xffff));
 552     }
 553
 554     /* Get the full path name */
 555
 556     if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
 557     {
 558         /* Check if we have write access in the directory */
 559         if ((p = strrchr( full_name.long_name, '/' ))) *p = '\0';
 560         if (access( full_name.long_name, W_OK ) == -1)
 561             fprintf( stderr,
 562                      "Warning: GetTempFileName returns '%s', which doesn't seem to be writeable.\n"
 563                      "Please check your configuration file if this generates a failure.\n",
 564                      buffer);
 565     }
 566     dprintf_file( stddeb, "GetTempFileName32A: returning %s\n", buffer );
 567     return unique ? unique : num;
 568 }
 569
 570
 571 /***********************************************************************
 572  *           GetTempFileName32W   (KERNEL32.291)
 573  */
 574 UINT32 GetTempFileName32W( LPCWSTR path, LPCWSTR prefix, UINT32 unique,
 575                            LPWSTR buffer )
 576 {
 577     LPSTR   patha,prefixa;
 578     char    buffera[144];
 579     UINT32  ret;
 580
 581     if (!path) return 0;
 582     patha   = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
 583     prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
 584     ret     = GetTempFileName32A( patha, prefixa, unique, buffera );
 585     lstrcpyAtoW( buffer, buffera );
 586     HeapFree( GetProcessHeap(), 0, patha );
 587     HeapFree( GetProcessHeap(), 0, prefixa );
 588     return ret;
 589 }
 590
 591
 592 /***********************************************************************
 593  *           FILE_DoOpenFile
 594  *
 595  * Implementation of OpenFile16() and OpenFile32().
 596  */
 597 static HFILE32 FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT32 mode,
 598                                 BOOL32 win32 )
 599 {
 600     HFILE32 hFileRet;
 601     FILETIME filetime;
 602     WORD filedatetime[2];
 603     DOS_FULL_NAME full_name;
 604     char *p;
 605     int unixMode;
 606
 607     ofs->cBytes = sizeof(OFSTRUCT);
 608     ofs->nErrCode = 0;
 609     if (mode & OF_REOPEN) name = ofs->szPathName;
 610     dprintf_file( stddeb, "OpenFile: %s %04x\n", name, mode );
 611
 612     /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
 613        Are there any cases where getting the path here is wrong?
 614        Uwe Bonnes 1997 Apr 2 */
 615     if (!GetFullPathName32A( name, sizeof(ofs->szPathName),
 616                              ofs->szPathName, NULL )) goto error;
 617
 618     /* OF_PARSE simply fills the structure */
 619
 620     if (mode & OF_PARSE)
 621     {
 622         ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
 623                            != DRIVE_REMOVABLE);
 624         dprintf_file( stddeb, "OpenFile(%s): OF_PARSE, res = '%s'\n",
 625                       name, ofs->szPathName );
 626         return 0;
 627     }
 628
 629     /* OF_CREATE is completely different from all other options, so
 630        handle it first */
 631
 632     if (mode & OF_CREATE)
 633     {
 634         if ((hFileRet = FILE_Create(name,0666,FALSE))== INVALID_HANDLE_VALUE32)
 635             goto error;
 636         goto success;
 637     }
 638
 639     /* If OF_SEARCH is set, ignore the given path */
 640
 641     if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
 642     {
 643         /* First try the file name as is */
 644         if (DOSFS_GetFullName( name, TRUE, &full_name )) goto found;
 645         /* Now remove the path */
 646         if (name[0] && (name[1] == ':')) name += 2;
 647         if ((p = strrchr( name, '\\' ))) name = p + 1;
 648         if ((p = strrchr( name, '/' ))) name = p + 1;
 649         if (!name[0]) goto not_found;
 650     }
 651
 652     /* Now look for the file */
 653
 654     if (!DIR_SearchPath( NULL, name, NULL, &full_name, win32 )) goto not_found;
 655
 656 found:
 657     dprintf_file( stddeb, "OpenFile: found %s = %s\n",
 658                   full_name.long_name, full_name.short_name );
 659     lstrcpyn32A( ofs->szPathName, full_name.short_name,
 660                  sizeof(ofs->szPathName) );
 661
 662     if (mode & OF_DELETE)
 663     {
 664         if (unlink( full_name.long_name ) == -1) goto not_found;
 665         dprintf_file( stddeb, "OpenFile(%s): OF_DELETE return = OK\n", name);
 666         return 1;
 667     }
 668
 669     switch(mode & 3)
 670     {
 671     case OF_WRITE:
 672         unixMode = O_WRONLY; break;
 673     case OF_READWRITE:
 674         unixMode = O_RDWR; break;
 675     case OF_READ:
 676     default:
 677         unixMode = O_RDONLY; break;
 678     }
 679
 680     hFileRet = FILE_OpenUnixFile( full_name.long_name, unixMode );
 681     if (hFileRet == HFILE_ERROR32) goto not_found;
 682     GetFileTime( hFileRet, NULL, NULL, &filetime );
 683     FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
 684     if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
 685     {
 686         if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
 687         {
 688             CloseHandle( hFileRet );
 689             dprintf_file( stddeb, "OpenFile(%s): OF_VERIFY failed\n", name );
 690             /* FIXME: what error here? */
 691             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 692             goto error;
 693         }
 694     }
 695     memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
 696
 697 success:  /* We get here if the open was successful */
 698     dprintf_file( stddeb, "OpenFile(%s): OK, return = %d\n", name, hFileRet );
 699     if (mode & OF_EXIST) /* Return the handle, but close it first */
 700         CloseHandle( hFileRet );
 701     return hFileRet;
 702
 703 not_found:  /* We get here if the file does not exist */
 704     dprintf_file( stddeb, "OpenFile: '%s' not found\n", name );
 705     DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 706     /* fall through */
 707
 708 error:  /* We get here if there was an error opening the file */
 709     ofs->nErrCode = DOS_ExtendedError;
 710     dprintf_file( stddeb, "OpenFile(%s): return = HFILE_ERROR error= %d\n",
 711                   name,ofs->nErrCode );
 712     return HFILE_ERROR32;
 713 }
 714
 715
 716 /***********************************************************************
 717  *           OpenFile16   (KERNEL.74)
 718  */
 719 HFILE16 OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
 720 {
 721     return FILE_DoOpenFile( name, ofs, mode, FALSE );
 722 }
 723
 724
 725 /***********************************************************************
 726  *           OpenFile32   (KERNEL32.396)
 727  */
 728 HFILE32 OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode )
 729 {
 730     return FILE_DoOpenFile( name, ofs, mode, TRUE );
 731 }
 732
 733
 734 /***********************************************************************
 735  *           _lclose16   (KERNEL.81)
 736  */
 737 HFILE16 _lclose16( HFILE16 hFile )
 738 {
 739     dprintf_file( stddeb, "_lclose16: handle %d\n", hFile );
 740     return CloseHandle( hFile ) ? 0 : HFILE_ERROR16;
 741 }
 742
 743
 744 /***********************************************************************
 745  *           _lclose32   (KERNEL32.592)
 746  */
 747 HFILE32 _lclose32( HFILE32 hFile )
 748 {
 749     dprintf_file( stddeb, "_lclose32: handle %d\n", hFile );
 750     return CloseHandle( hFile ) ? 0 : HFILE_ERROR32;
 751 }
 752
 753
 754 /***********************************************************************
 755  *           WIN16_hread
 756  */
 757 LONG WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
 758 {
 759     LONG maxlen;
 760
 761     dprintf_file( stddeb, "WIN16_hread: %d %08lx %ld\n",
 762                   hFile, (DWORD)buffer, count );
 763
 764     /* Some programs pass a count larger than the allocated buffer */
 765     maxlen = GetSelectorLimit( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
 766     if (count > maxlen) count = maxlen;
 767     return _lread32( hFile, PTR_SEG_TO_LIN(buffer), count );
 768 }
 769
 770
 771 /***********************************************************************
 772  *           WIN16_lread
 773  */
 774 UINT16 WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
 775 {
 776     return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
 777 }
 778
 779
 780 /***********************************************************************
 781  *           _lread32   (KERNEL32.596)
 782  */
 783 UINT32 _lread32( HFILE32 hFile, LPVOID buffer, UINT32 count )
 784 {
 785     FILE_OBJECT *file;
 786     UINT32 result;
 787
 788     dprintf_file( stddeb, "_lread32: %d %p %d\n", hFile, buffer, count );
 789     if (!(file = FILE_GetFile( hFile ))) return -1;
 790     if (!count) result = 0;
 791     else if ((result = read( file->unix_handle, buffer, count )) == -1)
 792         FILE_SetDosError();
 793     FILE_ReleaseFile( file );
 794     return result;
 795 }
 796
 797
 798 /***********************************************************************
 799  *           _lread16   (KERNEL.82)
 800  */
 801 UINT16 _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
 802 {
 803     return (UINT16)_lread32( hFile, buffer, (LONG)count );
 804 }
 805
 806
 807 /***********************************************************************
 808  *           _lcreat16   (KERNEL.83)
 809  */
 810 HFILE16 _lcreat16( LPCSTR path, INT16 attr )
 811 {
 812     int mode = (attr & 1) ? 0444 : 0666;
 813     dprintf_file( stddeb, "_lcreat16: %s %02x\n", path, attr );
 814     return (HFILE16)FILE_Create( path, mode, FALSE );
 815 }
 816
 817
 818 /***********************************************************************
 819  *           _lcreat32   (KERNEL32.593)
 820  */
 821 HFILE32 _lcreat32( LPCSTR path, INT32 attr )
 822 {
 823     int mode = (attr & 1) ? 0444 : 0666;
 824     dprintf_file( stddeb, "_lcreat32: %s %02x\n", path, attr );
 825     return FILE_Create( path, mode, FALSE );
 826 }
 827
 828
 829 /***********************************************************************
 830  *           _lcreat_uniq   (Not a Windows API)
 831  */
 832 HFILE32 _lcreat_uniq( LPCSTR path, INT32 attr )
 833 {
 834     int mode = (attr & 1) ? 0444 : 0666;
 835     dprintf_file( stddeb, "_lcreat_uniq: %s %02x\n", path, attr );
 836     return FILE_Create( path, mode, TRUE );
 837 }
 838
 839
 840 /***********************************************************************
 841  *           SetFilePointer   (KERNEL32.492)
 842  */
 843 DWORD SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword,
 844                       DWORD method )
 845 {
 846     FILE_OBJECT *file;
 847     int origin, result;
 848
 849     if (highword && *highword)
 850     {
 851         fprintf( stderr, "SetFilePointer: 64-bit offsets not supported yet\n");
 852         SetLastError( ERROR_INVALID_PARAMETER );
 853         return 0xffffffff;
 854     }
 855     dprintf_file( stddeb, "SetFilePointer: handle %d offset %ld origin %ld\n",
 856                   hFile, distance, method );
 857
 858     if (!(file = FILE_GetFile( hFile ))) return 0xffffffff;
 859     switch(method)
 860     {
 861         case FILE_CURRENT: origin = SEEK_CUR; break;
 862         case FILE_END:     origin = SEEK_END; break;
 863         default:           origin = SEEK_SET; break;
 864     }
 865
 866     if ((result = lseek( file->unix_handle, distance, origin )) == -1)
 867         FILE_SetDosError();
 868     FILE_ReleaseFile( file );
 869     return (DWORD)result;
 870 }
 871
 872
 873 /***********************************************************************
 874  *           _llseek16   (KERNEL.84)
 875  */
 876 LONG _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
 877 {
 878     return SetFilePointer( hFile, lOffset, NULL, nOrigin );
 879 }
 880
 881
 882 /***********************************************************************
 883  *           _llseek32   (KERNEL32.594)
 884  */
 885 LONG _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin )
 886 {
 887     return SetFilePointer( hFile, lOffset, NULL, nOrigin );
 888 }
 889
 890
 891 /***********************************************************************
 892  *           _lopen16   (KERNEL.85)
 893  */
 894 HFILE16 _lopen16( LPCSTR path, INT16 mode )
 895 {
 896     return _lopen32( path, mode );
 897 }
 898
 899
 900 /***********************************************************************
 901  *           _lopen32   (KERNEL32.595)
 902  */
 903 HFILE32 _lopen32( LPCSTR path, INT32 mode )
 904 {
 905     INT32 unixMode;
 906
 907     dprintf_file(stddeb, "_lopen32('%s',%04x)\n", path, mode );
 908
 909     switch(mode & 3)
 910     {
 911     case OF_WRITE:
 912         unixMode = O_WRONLY | O_TRUNC;
 913         break;
 914     case OF_READWRITE:
 915         unixMode = O_RDWR;
 916         break;
 917     case OF_READ:
 918     default:
 919         unixMode = O_RDONLY;
 920         break;
 921     }
 922     return FILE_Open( path, unixMode );
 923 }
 924
 925
 926 /***********************************************************************
 927  *           _lwrite16   (KERNEL.86)
 928  */
 929 UINT16 _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
 930 {
 931     return (UINT16)_hwrite32( hFile, buffer, (LONG)count );
 932 }
 933
 934 /***********************************************************************
 935  *           _lwrite32   (KERNEL.86)
 936  */
 937 UINT32 _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count )
 938 {
 939     return (UINT32)_hwrite32( hFile, buffer, (LONG)count );
 940 }
 941
 942
 943 /***********************************************************************
 944  *           _hread16   (KERNEL.349)
 945  */
 946 LONG _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
 947 {
 948     return _lread32( hFile, buffer, count );
 949 }
 950
 951
 952 /***********************************************************************
 953  *           _hread32   (KERNEL32.590)
 954  */
 955 LONG _hread32( HFILE32 hFile, LPVOID buffer, LONG count)
 956 {
 957     return _lread32( hFile, buffer, count );
 958 }
 959
 960
 961 /***********************************************************************
 962  *           _hwrite16   (KERNEL.350)
 963  */
 964 LONG _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
 965 {
 966     return _hwrite32( hFile, buffer, count );
 967 }
 968
 969
 970 /***********************************************************************
 971  *           _hwrite32   (KERNEL32.591)
 972  */
 973 LONG _hwrite32( HFILE32 hFile, LPCSTR buffer, LONG count )
 974 {
 975     FILE_OBJECT *file;
 976     LONG result;
 977
 978     dprintf_file( stddeb, "_hwrite32: %d %p %ld\n", hFile, buffer, count );
 979
 980     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR32;
 981     if (count == 0)  /* Expand or truncate at current position */
 982         result = ftruncate( file->unix_handle,
 983                             lseek( file->unix_handle, 0, SEEK_CUR ) );
 984     else
 985         result = write( file->unix_handle, buffer, count );
 986
 987     if (result == -1) FILE_SetDosError();
 988     FILE_ReleaseFile( file );
 989     return result;
 990 }
 991
 992
 993 /***********************************************************************
 994  *           SetHandleCount16   (KERNEL.199)
 995  */
 996 UINT16 SetHandleCount16( UINT16 count )
 997 {
 998     HGLOBAL16 hPDB = GetCurrentPDB();
 999     PDB *pdb = (PDB *)GlobalLock16( hPDB );
1000     BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
1001
1002     dprintf_file( stddeb, "SetHandleCount16(%d)\n", count );
1003
1004     if (count < 20) count = 20;  /* No point in going below 20 */
1005     else if (count > 254) count = 254;
1006
1007     if (count == 20)
1008     {
1009         if (pdb->nbFiles > 20)
1010         {
1011             memcpy( pdb->fileHandles, files, 20 );
1012             GlobalFree16( pdb->hFileHandles );
1013             pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18,
1014                                                    GlobalHandleToSel( hPDB ) );
1015             pdb->hFileHandles = 0;
1016             pdb->nbFiles = 20;
1017         }
1018     }
1019     else  /* More than 20, need a new file handles table */
1020     {
1021         BYTE *newfiles;
1022         HGLOBAL16 newhandle = GlobalAlloc16( GMEM_MOVEABLE, count );
1023         if (!newhandle)
1024         {
1025             DOS_ERROR( ER_OutOfMemory, EC_OutOfResource, SA_Abort, EL_Memory );
1026             return pdb->nbFiles;
1027         }
1028         newfiles = (BYTE *)GlobalLock16( newhandle );
1029
1030         if (count > pdb->nbFiles)
1031         {
1032             memcpy( newfiles, files, pdb->nbFiles );
1033             memset( newfiles + pdb->nbFiles, 0xff, count - pdb->nbFiles );
1034         }
1035         else memcpy( newfiles, files, count );
1036         if (pdb->nbFiles > 20) GlobalFree16( pdb->hFileHandles );
1037         pdb->fileHandlesPtr = WIN16_GlobalLock16( newhandle );
1038         pdb->hFileHandles   = newhandle;
1039         pdb->nbFiles = count;
1040     }
1041     return pdb->nbFiles;
1042 }
1043
1044
1045 /*************************************************************************
1046  *           SetHandleCount32   (KERNEL32.494)
1047  */
1048 UINT32 SetHandleCount32( UINT32 count )
1049 {
1050     return MIN( 256, count );
1051 }
1052
1053
1054 /***********************************************************************
1055  *           FlushFileBuffers   (KERNEL32.133)
1056  */
1057 BOOL32 FlushFileBuffers( HFILE32 hFile )
1058 {
1059     FILE_OBJECT *file;
1060     BOOL32 ret;
1061
1062     dprintf_file( stddeb, "FlushFileBuffers(%d)\n", hFile );
1063     if (!(file = FILE_GetFile( hFile ))) return FALSE;
1064     if (fsync( file->unix_handle ) != -1) ret = TRUE;
1065     else
1066     {
1067         FILE_SetDosError();
1068         ret = FALSE;
1069     }
1070     FILE_ReleaseFile( file );
1071     return ret;
1072 }
1073
1074
1075 /**************************************************************************
1076  *           SetEndOfFile   (KERNEL32.483)
1077  */
1078 BOOL32 SetEndOfFile( HFILE32 hFile )
1079 {
1080     FILE_OBJECT *file;
1081     BOOL32 ret = TRUE;
1082
1083     dprintf_file( stddeb, "SetEndOfFile(%d)\n", hFile );
1084     if (!(file = FILE_GetFile( hFile ))) return FALSE;
1085     if (ftruncate( file->unix_handle,
1086                    lseek( file->unix_handle, 0, SEEK_CUR ) ))
1087     {
1088         FILE_SetDosError();
1089         ret = FALSE;
1090     }
1091     FILE_ReleaseFile( file );
1092     return ret;
1093 }
1094
1095
1096 /***********************************************************************
1097  *           DeleteFile16   (KERNEL.146)
1098  */
1099 BOOL16 DeleteFile16( LPCSTR path )
1100 {
1101     return DeleteFile32A( path );
1102 }
1103
1104
1105 /***********************************************************************
1106  *           DeleteFile32A   (KERNEL32.71)
1107  */
1108 BOOL32 DeleteFile32A( LPCSTR path )
1109 {
1110     DOS_FULL_NAME full_name;
1111     const char *unixName;
1112
1113     dprintf_file(stddeb, "DeleteFile: '%s'\n", path );
1114
1115     if ((unixName = DOSFS_IsDevice( path )) != NULL)
1116     {
1117         dprintf_file(stddeb, "DeleteFile: removing device '%s'!\n", unixName);
1118         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
1119         return FALSE;
1120     }
1121
1122     if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
1123     if (unlink( full_name.long_name ) == -1)
1124     {
1125         FILE_SetDosError();
1126         return FALSE;
1127     }
1128     return TRUE;
1129 }
1130
1131
1132 /***********************************************************************
1133  *           DeleteFile32W   (KERNEL32.72)
1134  */
1135 BOOL32 DeleteFile32W( LPCWSTR path )
1136 {
1137     LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1138     BOOL32 ret = RemoveDirectory32A( xpath );
1139     HeapFree( GetProcessHeap(), 0, xpath );
1140     return ret;
1141 }
1142
1143
1144 /***********************************************************************
1145  *           FILE_SetFileType
1146  */
1147 BOOL32 FILE_SetFileType( HFILE32 hFile, DWORD type )
1148 {
1149     FILE_OBJECT *file = FILE_GetFile( hFile );
1150     if (!file) return FALSE;
1151     file->type = type;
1152     FILE_ReleaseFile( file );
1153     return TRUE;
1154 }
1155
1156
1157 /***********************************************************************
1158  *           FILE_mmap
1159  */
1160 LPVOID FILE_mmap( FILE_OBJECT *file, LPVOID start,
1161                   DWORD size_high, DWORD size_low,
1162                   DWORD offset_high, DWORD offset_low,
1163                   int prot, int flags )
1164 {
1165     int fd = -1;
1166
1167     if (size_high || offset_high)
1168         fprintf( stderr, "FILE_mmap: offsets larger than 4Gb not supported\n");
1169
1170     if (!file)
1171     {
1172         /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
1173         flags &= ~MAP_SHARED;
1174         flags |= MAP_PRIVATE;
1175 #ifdef MAP_ANON
1176         flags |= MAP_ANON;
1177 #else
1178         static int fdzero = -1;
1179
1180         if (fdzero == -1)
1181         {
1182             if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1)
1183             {
1184                 perror( "/dev/zero: open" );
1185                 exit(1);
1186             }
1187         }
1188         fd = fdzero;
1189 #endif  /* MAP_ANON */
1190     }
1191     else fd = file->unix_handle;
1192
1193     return mmap( start, size_low, prot, flags, fd, offset_low );
1194 }
1195
1196
1197 /***********************************************************************
1198  *           GetFileType   (KERNEL32.222)
1199  */
1200 DWORD GetFileType( HFILE32 hFile )
1201 {
1202     FILE_OBJECT *file = FILE_GetFile(hFile);
1203     if (!file) return FILE_TYPE_UNKNOWN; /* FIXME: correct? */
1204     FILE_ReleaseFile( file );
1205     return file->type;
1206 }
1207
1208
1209 /**************************************************************************
1210  *           MoveFile32A   (KERNEL32.387)
1211  */
1212 BOOL32 MoveFile32A( LPCSTR fn1, LPCSTR fn2 )
1213 {
1214     DOS_FULL_NAME full_name1, full_name2;
1215
1216     dprintf_file( stddeb, "MoveFile32A(%s,%s)\n", fn1, fn2 );
1217
1218     if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
1219     if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
1220     /* FIXME: should not replace an existing file */
1221     /* FIXME: should handle renaming across devices */
1222     if (rename( full_name1.long_name, full_name2.long_name ) == -1)
1223     {
1224         FILE_SetDosError();
1225         return FALSE;
1226     }
1227     return TRUE;
1228 }
1229
1230
1231 /**************************************************************************
1232  *           MoveFile32W   (KERNEL32.390)
1233  */
1234 BOOL32 MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 )
1235 {
1236     LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
1237     LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
1238     BOOL32 res = MoveFile32A( afn1, afn2 );
1239     HeapFree( GetProcessHeap(), 0, afn1 );
1240     HeapFree( GetProcessHeap(), 0, afn2 );
1241     return res;
1242 }
1243
1244
1245 /**************************************************************************
1246  *           CopyFile32A   (KERNEL32.36)
1247  */
1248 BOOL32 CopyFile32A( LPCSTR source, LPCSTR dest, BOOL32 fail_if_exists )
1249 {
1250     HFILE32 h1, h2;
1251     BY_HANDLE_FILE_INFORMATION info;
1252     UINT32 count;
1253     BOOL32 ret = FALSE;
1254     int mode;
1255     char buffer[2048];
1256
1257     if ((h1 = _lopen32( source, OF_READ )) == HFILE_ERROR32) return FALSE;
1258     if (!GetFileInformationByHandle( h1, &info ))
1259     {
1260         CloseHandle( h1 );
1261         return FALSE;
1262     }
1263     mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
1264     if ((h2 = FILE_Create( dest, mode, fail_if_exists )) == HFILE_ERROR32)
1265     {
1266         CloseHandle( h1 );
1267         return FALSE;
1268     }
1269     while ((count = _lread32( h2, buffer, sizeof(buffer) )) > 0)
1270     {
1271         char *p = buffer;
1272         while (count > 0)
1273         {
1274             INT32 res = _lwrite32( h2, p, count );
1275             if (res <= 0) goto done;
1276             p += res;
1277             count -= res;
1278         }
1279     }
1280     ret =  TRUE;
1281 done:
1282     CloseHandle( h1 );
1283     CloseHandle( h2 );
1284     return ret;
1285 }
1286
1287
1288 /**************************************************************************
1289  *           CopyFile32W   (KERNEL32.37)
1290  */
1291 BOOL32 CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists )
1292 {
1293     LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
1294     LPSTR destA   = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
1295     BOOL32 ret = CopyFile32A( sourceA, destA, fail_if_exists );
1296     HeapFree( GetProcessHeap(), 0, sourceA );
1297     HeapFree( GetProcessHeap(), 0, destA );
1298     return ret;
1299 }
1300
1301
1302 /***********************************************************************
1303  *              SetFileTime   (KERNEL32.493)
1304  */
1305 BOOL32 SetFileTime( HFILE32 hFile,
1306                     const FILETIME *lpCreationTime,
1307                     const FILETIME *lpLastAccessTime,
1308                     const FILETIME *lpLastWriteTime )
1309 {
1310     FILE_OBJECT *file = FILE_GetFile(hFile);
1311     struct utimbuf utimbuf;
1312
1313     if (!file) return FILE_TYPE_UNKNOWN; /* FIXME: correct? */
1314     dprintf_file(stddeb,"SetFileTime(%s,%p,%p,%p)\n",
1315         file->unix_name,
1316         lpCreationTime,
1317         lpLastAccessTime,
1318         lpLastWriteTime
1319     );
1320     if (lpLastAccessTime)
1321         utimbuf.actime  = DOSFS_FileTimeToUnixTime(lpLastAccessTime, NULL);
1322     else
1323         utimbuf.actime  = 0; /* FIXME */
1324     if (lpLastWriteTime)
1325         utimbuf.modtime = DOSFS_FileTimeToUnixTime(lpLastWriteTime, NULL);
1326     else
1327         utimbuf.modtime = 0; /* FIXME */
1328     if (-1==utime(file->unix_name,&utimbuf))
1329     {
1330         FILE_ReleaseFile( file );
1331         FILE_SetDosError();
1332         return FALSE;
1333     }
1334     FILE_ReleaseFile( file );
1335     return TRUE;
1336 }