files/file.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include <ctype.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <sys/errno.h>
  15 #include <sys/stat.h>
  16 #include <time.h>
  17 #include <unistd.h>
  18 #include <utime.h>
  19
  20 #include "windows.h"
  21 #include "directory.h"
  22 #include "dos_fs.h"
  23 #include "drive.h"
  24 #include "global.h"
  25 #include "msdos.h"
  26 #include "options.h"
  27 #include "ldt.h"
  28 #include "task.h"
  29 #include "stddebug.h"
  30 #include "debug.h"
  31 #include "xmalloc.h"
  32
  33 #define MAX_OPEN_FILES 64  /* Max. open files for all tasks; must be <255 */
  34
  35 typedef struct tagDOS_FILE
  36 {
  37     struct tagDOS_FILE *next;
  38     int                 count;        /* Usage count (0 if free) */
  39     int                 unix_handle;
  40     int                 mode;
  41     char               *unix_name;
  42     WORD                filedate;
  43     WORD                filetime;
  44 } DOS_FILE;
  45
  46 /* Global files array */
  47 static DOS_FILE DOSFiles[MAX_OPEN_FILES];
  48
  49 static DOS_FILE *FILE_First = DOSFiles;
  50 static DOS_FILE *FILE_LastUsed = DOSFiles;
  51
  52 /* Small file handles array for boot-up, before the first PDB is created */
  53 #define MAX_BOOT_HANDLES  4
  54 static BYTE bootFileHandles[MAX_BOOT_HANDLES] = { 0xff, 0xff, 0xff, 0xff };
  55
  56 /***********************************************************************
  57  *           FILE_Alloc
  58  *
  59  * Allocate a DOS file.
  60  */
  61 static DOS_FILE *FILE_Alloc(void)
  62 {
  63     DOS_FILE *file = FILE_First;
  64     if (file) FILE_First = file->next;
  65     else if (FILE_LastUsed >= &DOSFiles[MAX_OPEN_FILES-1])
  66     {
  67         DOS_ERROR( ER_TooManyOpenFiles, EC_ProgramError, SA_Abort, EL_Disk );
  68         return NULL;
  69     }
  70     else file = ++FILE_LastUsed;
  71     file->count = 1;
  72     file->unix_handle = -1;
  73     file->unix_name = NULL;
  74     return file;
  75 }
  76
  77
  78 /***********************************************************************
  79  *           FILE_Close
  80  *
  81  * Close a DOS file.
  82  */
  83 static BOOL FILE_Close( DOS_FILE *file )
  84 {
  85     if (!file->count) return FALSE;
  86     if (--file->count > 0) return TRUE;
  87     /* Now really close the file */
  88     if (file->unix_handle != -1) close( file->unix_handle );
  89     if (file->unix_name) free( file->unix_name );
  90     file->next = FILE_First;
  91     FILE_First = file;
  92     return TRUE;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           FILE_GetPDBFiles
  98  *
  99  * Return a pointer to the current PDB files array.
 100  */
 101 static void FILE_GetPDBFiles( BYTE **files, WORD *nbFiles )
 102 {
 103     PDB *pdb;
 104
 105     if ((pdb = (PDB *)GlobalLock16( GetCurrentPDB() )) != NULL)
 106     {
 107         *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
 108         *nbFiles = pdb->nbFiles;
 109     }
 110     else
 111     {
 112         *files = bootFileHandles;
 113         *nbFiles = MAX_BOOT_HANDLES;
 114     }
 115 }
 116
 117
 118 /***********************************************************************
 119  *           FILE_AllocTaskHandle
 120  *
 121  * Allocate a task file handle for a DOS file.
 122  */
 123 static HFILE FILE_AllocTaskHandle( DOS_FILE *dos_file )
 124 {
 125     BYTE *files, *fp;
 126     WORD i, nbFiles;
 127
 128     FILE_GetPDBFiles( &files, &nbFiles );
 129     fp = files + 1;  /* Don't use handle 0, as some programs don't like it */
 130     for (i = nbFiles - 1; (i > 0) && (*fp != 0xff); i--, fp++);
 131     if (!i)
 132     {  /* No more handles or files */
 133         DOS_ERROR( ER_TooManyOpenFiles, EC_ProgramError, SA_Abort, EL_Disk );
 134         return -1;
 135     }
 136     *fp = dos_file ? (BYTE)(dos_file - DOSFiles) : 0;
 137     dprintf_file(stddeb,
 138        "FILE_AllocTaskHandle: returning task handle %d, dos_file %d, file %d of %d \n",
 139              (fp - files), *fp, nbFiles - i, nbFiles  );
 140     return (HFILE)(fp - files);
 141 }
 142
 143
 144 /***********************************************************************
 145  *           FILE_FreeTaskHandle
 146  *
 147  * Free a per-task file handle.
 148  */
 149 static void FILE_FreeTaskHandle( HFILE handle )
 150 {
 151     BYTE *files;
 152     WORD nbFiles;
 153
 154     FILE_GetPDBFiles( &files, &nbFiles );
 155     dprintf_file( stddeb,"FILE_FreeTaskHandle: dos=%d file=%d\n",
 156                   handle, files[handle] );
 157     if ((handle < 0) || (handle >= (INT)nbFiles))
 158     {
 159         fprintf( stderr, "FILE_FreeTaskHandle: invalid file handle %d\n",
 160                  handle );
 161         return;
 162     }
 163     files[handle] = 0xff;
 164 }
 165
 166
 167 /***********************************************************************
 168  *           FILE_SetTaskHandle
 169  *
 170  * Set the value of a task handle (no error checking).
 171  */
 172 static void FILE_SetTaskHandle( HFILE handle, DOS_FILE *file )
 173 {
 174     BYTE *files;
 175     WORD nbFiles;
 176
 177     FILE_GetPDBFiles( &files, &nbFiles );
 178     files[handle] = (BYTE)(file - DOSFiles);
 179 }
 180
 181
 182 /***********************************************************************
 183  *           FILE_GetFile
 184  *
 185  * Return the DOS file associated to a task file handle.
 186  */
 187 static DOS_FILE *FILE_GetFile( HFILE handle )
 188 {
 189     BYTE *files;
 190     WORD nbFiles;
 191     DOS_FILE *file;
 192
 193     FILE_GetPDBFiles( &files, &nbFiles );
 194     if ((handle < 0) || (handle >= (INT)nbFiles) ||
 195         (files[handle] >= MAX_OPEN_FILES) ||
 196         !(file = &DOSFiles[files[handle]])->count)
 197     {
 198         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
 199         return NULL;
 200     }
 201     return file;
 202 }
 203
 204
 205 int FILE_GetUnixHandle( HFILE hFile )
 206 {
 207     DOS_FILE *file;
 208
 209     if (!(file = FILE_GetFile( hFile ))) return -1;
 210     return file->unix_handle;
 211 }
 212
 213
 214 /***********************************************************************
 215  *           FILE_CloseAllFiles
 216  *
 217  * Close all open files of a given PDB. Used on task termination.
 218  */
 219 void FILE_CloseAllFiles( HANDLE hPDB )
 220 {
 221     BYTE *files;
 222     WORD count;
 223     PDB *pdb = (PDB *)GlobalLock16( hPDB );
 224
 225     if (!pdb) return;
 226     files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
 227     dprintf_file(stddeb,"FILE_CloseAllFiles: closing %d files\n",pdb->nbFiles);
 228     for (count = pdb->nbFiles; count > 0; count--, files++)
 229     {
 230         if (*files < MAX_OPEN_FILES) FILE_Close( &DOSFiles[*files] );
 231         *files = 0xff;
 232     }
 233 }
 234
 235
 236 /***********************************************************************
 237  *           FILE_SetDosError
 238  *
 239  * Set the DOS error code from errno.
 240  */
 241 void FILE_SetDosError(void)
 242 {
 243     dprintf_file(stddeb, "FILE_SetDosError: errno = %d\n", errno );
 244     switch (errno)
 245     {
 246     case EAGAIN:
 247         DOS_ERROR( ER_ShareViolation, EC_Temporary, SA_Retry, EL_Disk );
 248         break;
 249     case EBADF:
 250         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
 251         break;
 252     case ENOSPC:
 253         DOS_ERROR( ER_DiskFull, EC_MediaError, SA_Abort, EL_Disk );
 254         break;
 255     case EACCES:
 256     case EPERM:
 257     case EROFS:
 258         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 259         break;
 260     case EBUSY:
 261         DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Abort, EL_Disk );
 262         break;
 263     case ENOENT:
 264         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 265         break;
 266     case EISDIR:
 267         DOS_ERROR( ER_CanNotMakeDir, EC_AccessDenied, SA_Abort, EL_Unknown );
 268         break;
 269     case ENFILE:
 270     case EMFILE:
 271         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Unknown );
 272         break;
 273     case EEXIST:
 274         DOS_ERROR( ER_FileExists, EC_Exists, SA_Abort, EL_Disk );
 275         break;
 276     default:
 277         perror( "int21: unknown errno" );
 278         DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, EL_Unknown );
 279         break;
 280     }
 281 }
 282
 283
 284 /***********************************************************************
 285  *           FILE_OpenUnixFile
 286  */
 287 static DOS_FILE *FILE_OpenUnixFile( const char *name, int mode )
 288 {
 289     DOS_FILE *file;
 290     struct stat st;
 291
 292     if (!(file = FILE_Alloc())) return NULL;
 293     if ((file->unix_handle = open( name, mode )) == -1)
 294     {
 295         if (Options.allowReadOnly && (mode == O_RDWR))
 296         {
 297             if ((file->unix_handle = open( name, O_RDONLY )) != -1)
 298                 fprintf( stderr, "Warning: could not open %s for writing, opening read-only.\n", name );
 299         }
 300     }
 301     if ((file->unix_handle == -1) || (fstat( file->unix_handle, &st ) == -1))
 302     {
 303         FILE_SetDosError();
 304         FILE_Close( file );
 305         return NULL;
 306     }
 307     if (S_ISDIR(st.st_mode))
 308     {
 309         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 310         FILE_Close( file );
 311         return NULL;
 312     }
 313
 314     /* File opened OK, now fill the DOS_FILE */
 315
 316     file->unix_name = xstrdup( name );
 317     DOSFS_ToDosDateTime( st.st_mtime, &file->filedate, &file->filetime );
 318     return file;
 319 }
 320
 321
 322 /***********************************************************************
 323  *           FILE_Open
 324  */
 325 static DOS_FILE *FILE_Open( LPCSTR path, int mode )
 326 {
 327     const char *unixName;
 328
 329     dprintf_file(stddeb, "FILE_Open: '%s' %04x\n", path, mode );
 330     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 331     {
 332         dprintf_file( stddeb, "FILE_Open: opening device '%s'\n", unixName );
 333         if (!unixName[0])  /* Non-existing device */
 334         {
 335             dprintf_file(stddeb, "FILE_Open: Non-existing device\n");
 336             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 337             return NULL;
 338         }
 339     }
 340     else if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return NULL;
 341     return FILE_OpenUnixFile( unixName, mode );
 342 }
 343
 344
 345 /***********************************************************************
 346  *           FILE_Create
 347  */
 348 static DOS_FILE *FILE_Create( LPCSTR path, int mode, int unique )
 349 {
 350     DOS_FILE *file;
 351     const char *unixName;
 352
 353     dprintf_file(stddeb, "FILE_Create: '%s' %04x %d\n", path, mode, unique );
 354
 355     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 356     {
 357         dprintf_file(stddeb, "FILE_Create: creating device '%s'!\n", unixName);
 358         DOS_ERROR( ER_AccessDenied, EC_NotFound, SA_Abort, EL_Disk );
 359         return NULL;
 360     }
 361
 362     if (!(file = FILE_Alloc())) return NULL;
 363
 364     if (!(unixName = DOSFS_GetUnixFileName( path, FALSE )))
 365     {
 366         FILE_Close( file );
 367         return NULL;
 368     }
 369     if ((file->unix_handle = open( unixName,
 370                            O_CREAT | O_TRUNC | O_RDWR | (unique ? O_EXCL : 0),
 371                            mode )) == -1)
 372     {
 373         FILE_SetDosError();
 374         FILE_Close( file );
 375         return NULL;
 376     }
 377
 378     /* File created OK, now fill the DOS_FILE */
 379
 380     file->unix_name = xstrdup( unixName );
 381     DOSFS_ToDosDateTime( time(NULL), &file->filedate, &file->filetime );
 382     return file;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           FILE_Unlink
 388  */
 389 int FILE_Unlink( LPCSTR path )
 390 {
 391     const char *unixName;
 392
 393     dprintf_file(stddeb, "FILE_Unlink: '%s'\n", path );
 394
 395     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 396     {
 397         dprintf_file(stddeb, "FILE_Unlink: removing device '%s'!\n", unixName);
 398         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 399         return 0;
 400     }
 401
 402     if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return 0;
 403     if (unlink( unixName ) == -1)
 404     {
 405         FILE_SetDosError();
 406         return 0;
 407     }
 408     return 1;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           FILE_Stat
 414  *
 415  * Stat a Unix path name. Return 1 if OK.
 416  */
 417 int FILE_Stat( LPCSTR unixName, BYTE *pattr, DWORD *psize,
 418                WORD *pdate, WORD *ptime )
 419 {
 420     struct stat st;
 421
 422     if (stat( unixName, &st ) == -1)
 423     {
 424         FILE_SetDosError();
 425         return 0;
 426     }
 427     if (pattr) *pattr = FA_ARCHIVE | (S_ISDIR(st.st_mode) ? FA_DIRECTORY : 0);
 428     if (psize) *psize = S_ISDIR(st.st_mode) ? 0 : st.st_size;
 429     DOSFS_ToDosDateTime( st.st_mtime, pdate, ptime );
 430     return 1;
 431 }
 432
 433
 434 /***********************************************************************
 435  *           FILE_GetDateTime
 436  *
 437  * Get the date and time of a file.
 438  */
 439 int FILE_GetDateTime( HFILE hFile, WORD *pdate, WORD *ptime, BOOL refresh )
 440 {
 441     DOS_FILE *file;
 442
 443     if (!(file = FILE_GetFile( hFile ))) return 0;
 444     if (refresh)
 445     {
 446         struct stat st;
 447         if (fstat( file->unix_handle, &st ) == -1)
 448         {
 449             FILE_SetDosError();
 450             return 0;
 451         }
 452         DOSFS_ToDosDateTime( st.st_mtime, &file->filedate, &file->filetime );
 453     }
 454     *pdate = file->filedate;
 455     *ptime = file->filetime;
 456     return 1;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           FILE_SetDateTime
 462  *
 463  * Set the date and time of a file.
 464  */
 465 int FILE_SetDateTime( HFILE hFile, WORD date, WORD time )
 466 {
 467     DOS_FILE *file;
 468     struct tm newtm;
 469     struct utimbuf filetime;
 470
 471     if (!(file = FILE_GetFile( hFile ))) return 0;
 472     newtm.tm_sec  = (time & 0x1f) * 2;
 473     newtm.tm_min  = (time >> 5) & 0x3f;
 474     newtm.tm_hour = (time >> 11);
 475     newtm.tm_mday = (date & 0x1f);
 476     newtm.tm_mon  = ((date >> 5) & 0x0f) - 1;
 477     newtm.tm_year = (date >> 9) + 80;
 478
 479     filetime.actime = filetime.modtime = mktime( &newtm );
 480     if (utime( file->unix_name, &filetime ) != -1) return 1;
 481     FILE_SetDosError();
 482     return 0;
 483 }
 484
 485
 486 /***********************************************************************
 487  *           FILE_Sync
 488  */
 489 int FILE_Sync( HFILE hFile )
 490 {
 491     DOS_FILE *file;
 492
 493     if (!(file = FILE_GetFile( hFile ))) return 0;
 494     if (fsync( file->unix_handle ) != -1) return 1;
 495     FILE_SetDosError();
 496     return 0;
 497 }
 498
 499
 500 /***********************************************************************
 501  *           FILE_MakeDir
 502  */
 503 int FILE_MakeDir( LPCSTR path )
 504 {
 505     const char *unixName;
 506
 507     dprintf_file(stddeb, "FILE_MakeDir: '%s'\n", path );
 508
 509     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 510     {
 511         dprintf_file(stddeb, "FILE_MakeDir: device '%s'!\n", unixName);
 512         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 513         return 0;
 514     }
 515     if (!(unixName = DOSFS_GetUnixFileName( path, FALSE ))) return 0;
 516     if ((mkdir( unixName, 0777 ) == -1) && (errno != EEXIST))
 517     {
 518         FILE_SetDosError();
 519         return 0;
 520     }
 521     return 1;
 522 }
 523
 524
 525 /***********************************************************************
 526  *           FILE_RemoveDir
 527  */
 528 int FILE_RemoveDir( LPCSTR path )
 529 {
 530     const char *unixName;
 531
 532     dprintf_file(stddeb, "FILE_RemoveDir: '%s'\n", path );
 533
 534     if ((unixName = DOSFS_IsDevice( path )) != NULL)
 535     {
 536         dprintf_file(stddeb, "FILE_RemoveDir: device '%s'!\n", unixName);
 537         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 538         return 0;
 539     }
 540     if (!(unixName = DOSFS_GetUnixFileName( path, TRUE ))) return 0;
 541     if (rmdir( unixName ) == -1)
 542     {
 543         FILE_SetDosError();
 544         return 0;
 545     }
 546     return 1;
 547 }
 548
 549
 550 /***********************************************************************
 551  *           FILE_Dup
 552  *
 553  * dup() function for DOS handles.
 554  */
 555 HFILE FILE_Dup( HFILE hFile )
 556 {
 557     DOS_FILE *file;
 558     HFILE handle;
 559
 560     dprintf_file( stddeb, "FILE_Dup for handle %d\n", hFile );
 561     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR;
 562     if ((handle = FILE_AllocTaskHandle( file )) != HFILE_ERROR) file->count++;
 563     dprintf_file( stddeb, "FILE_Dup return handle %d\n", handle );
 564     return handle;
 565 }
 566
 567
 568 /***********************************************************************
 569  *           FILE_Dup2
 570  *
 571  * dup2() function for DOS handles.
 572  */
 573 HFILE FILE_Dup2( HFILE hFile1, HFILE hFile2 )
 574 {
 575     DOS_FILE *file;
 576     PDB *pdb = (PDB *)GlobalLock16( GetCurrentPDB() );
 577     BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
 578
 579     dprintf_file( stddeb, "FILE_Dup2 for handle %d\n", hFile1 );
 580     if (!(file = FILE_GetFile( hFile1 ))) return HFILE_ERROR;
 581
 582     if ((hFile2 < 0) || (hFile2 >= (INT)pdb->nbFiles))
 583     {
 584         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
 585         return HFILE_ERROR;
 586     }
 587     if (files[hFile2] < MAX_OPEN_FILES)
 588     {
 589         dprintf_file( stddeb, "FILE_Dup2 closing old handle2 %d\n",
 590                       files[hFile2] );
 591         FILE_Close( &DOSFiles[files[hFile2]] );
 592     }
 593     files[hFile2] = (BYTE)(file - DOSFiles);
 594     file->count++;
 595     dprintf_file( stddeb, "FILE_Dup2 return handle2 %d\n", hFile2 );
 596     return hFile2;
 597 }
 598
 599
 600 /***********************************************************************
 601  *           FILE_Read
 602  */
 603 INT32 FILE_Read( HFILE hFile, LPVOID buffer, UINT32 count )
 604 {
 605     DOS_FILE *file;
 606     INT32 result;
 607
 608     dprintf_file( stddeb, "FILE_Read: %d %p %d\n", hFile, buffer, count );
 609     if (!(file = FILE_GetFile( hFile ))) return -1;
 610     if (!count) return 0;
 611     if ((result = read( file->unix_handle, buffer, count )) == -1)
 612         FILE_SetDosError();
 613     return result;
 614 }
 615
 616
 617 /***********************************************************************
 618  *           GetTempFileName   (KERNEL.97)
 619  */
 620 INT GetTempFileName( BYTE drive, LPCSTR prefix, UINT unique, LPSTR buffer )
 621 {
 622     int i;
 623     UINT num = unique ? (unique & 0xffff) : time(NULL) & 0xffff;
 624     char *p;
 625
 626     if ((drive & TF_FORCEDRIVE) &&
 627         !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
 628     {
 629         drive &= ~TF_FORCEDRIVE;
 630         fprintf( stderr, "Warning: GetTempFileName: invalid drive %d specified\n",
 631                  drive );
 632     }
 633
 634     if (drive & TF_FORCEDRIVE)
 635     {
 636         sprintf( buffer, "%c:", drive & ~TF_FORCEDRIVE );
 637     }
 638     else
 639     {
 640         DIR_GetTempDosDir( buffer, 132 );  /* buffer must be at least 144 */
 641         strcat( buffer, "\\" );
 642     }
 643
 644     p = buffer + strlen(buffer);
 645     for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
 646     sprintf( p, "%04x.tmp", num );
 647
 648     if (unique)
 649     {
 650         lstrcpyn32A( buffer, DOSFS_GetDosTrueName( buffer, FALSE ), 144 );
 651         dprintf_file( stddeb, "GetTempFileName: returning %s\n", buffer );
 652         return unique;
 653     }
 654
 655     /* Now try to create it */
 656
 657     do
 658     {
 659         DOS_FILE *file;
 660         if ((file = FILE_Create( buffer, 0666, TRUE )) != NULL)
 661         {  /* We created it */
 662             dprintf_file( stddeb, "GetTempFileName: created %s\n", buffer );
 663             FILE_Close( file );
 664             break;
 665         }
 666         if (DOS_ExtendedError != ER_FileExists) break;  /* No need to go on */
 667         num++;
 668         sprintf( p, "%04x.tmp", num );
 669     } while (num != (unique & 0xffff));
 670
 671     lstrcpyn32A( buffer, DOSFS_GetDosTrueName( buffer, FALSE ), 144 );
 672     dprintf_file( stddeb, "GetTempFileName: returning %s\n", buffer );
 673     return num;
 674 }
 675
 676
 677 /***********************************************************************
 678  *           OpenFile   (KERNEL.74)
 679  */
 680 HFILE OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
 681 {
 682     DOS_FILE *file;
 683     HFILE hFileRet;
 684     WORD filedatetime[2];
 685     const char *unixName, *dosName;
 686     char *p;
 687     int len, i, unixMode;
 688
 689     ofs->cBytes = sizeof(OFSTRUCT);
 690     ofs->nErrCode = 0;
 691     if (mode & OF_REOPEN) name = ofs->szPathName;
 692     dprintf_file( stddeb, "OpenFile: %s %04x\n", name, mode );
 693
 694     /* First allocate a task handle */
 695
 696     if ((hFileRet = FILE_AllocTaskHandle( NULL )) == HFILE_ERROR)
 697     {
 698         ofs->nErrCode = DOS_ExtendedError;
 699         dprintf_file( stddeb, "OpenFile: no more task handles.\n" );
 700         return HFILE_ERROR;
 701     }
 702
 703     /* OF_PARSE simply fills the structure */
 704
 705     if (mode & OF_PARSE)
 706     {
 707         if (!(dosName = DOSFS_GetDosTrueName( name, FALSE ))) goto error;
 708         lstrcpyn32A( ofs->szPathName, dosName, sizeof(ofs->szPathName) );
 709         ofs->fFixedDisk = (GetDriveType( dosName[0]-'A' ) != DRIVE_REMOVABLE);
 710         dprintf_file( stddeb, "OpenFile(%s): OF_PARSE, res = '%s', %d\n",
 711                       name, ofs->szPathName, hFileRet );
 712         /* Return the handle, but close it first */
 713         FILE_FreeTaskHandle( hFileRet );
 714 /*        return hFileRet; */
 715         return 0;  /* Progman seems to like this better */
 716     }
 717
 718     /* OF_CREATE is completely different from all other options, so
 719        handle it first */
 720
 721     if (mode & OF_CREATE)
 722     {
 723         if (!(file = FILE_Create( name, 0666, FALSE ))) goto error;
 724         lstrcpyn32A( ofs->szPathName, DOSFS_GetDosTrueName( name, FALSE ),
 725                      sizeof(ofs->szPathName) );
 726         goto success;
 727     }
 728
 729     /* Now look for the file */
 730
 731     /* First try the current directory */
 732
 733     lstrcpyn32A( ofs->szPathName, name, sizeof(ofs->szPathName) );
 734     if ((unixName = DOSFS_GetUnixFileName( ofs->szPathName, TRUE )) != NULL)
 735         goto found;
 736
 737     /* Now try some different paths if none was specified */
 738
 739     if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
 740     {
 741         if (name[1] == ':') name += 2;
 742         if ((p = strrchr( name, '\\' ))) name = p + 1;
 743         if ((p = strrchr( name, '/' ))) name = p + 1;
 744         if (!name[0]) goto not_found;
 745     }
 746     else
 747     {
 748         if ((name[1] == ':') || strchr( name, '/' ) || strchr( name, '\\' ))
 749             goto not_found;
 750     }
 751
 752     if ((len = sizeof(ofs->szPathName) - strlen(name) - 1) < 0) goto not_found;
 753
 754     /* Try the Windows directory */
 755
 756     GetWindowsDirectory( ofs->szPathName, len );
 757     strcat( ofs->szPathName, "\\" );
 758     strcat( ofs->szPathName, name );
 759     if ((unixName = DOSFS_GetUnixFileName( ofs->szPathName, TRUE )) != NULL)
 760         goto found;
 761
 762     /* Try the Windows system directory */
 763
 764     GetSystemDirectory( ofs->szPathName, len );
 765     strcat( ofs->szPathName, "\\" );
 766     strcat( ofs->szPathName, name );
 767     if ((unixName = DOSFS_GetUnixFileName( ofs->szPathName, TRUE )) != NULL)
 768         goto found;
 769
 770     /* Try the path of the current executable */
 771
 772     if (GetCurrentTask())
 773     {
 774         GetModuleFileName( GetCurrentTask(), ofs->szPathName, len );
 775         if ((p = strrchr( ofs->szPathName, '\\' )))
 776         {
 777             strcpy( p + 1, name );
 778             if ((unixName = DOSFS_GetUnixFileName( ofs->szPathName, TRUE )))
 779                 goto found;
 780         }
 781     }
 782
 783     /* Try all directories in path */
 784
 785     for (i = 0; ; i++)
 786     {
 787         if (!DIR_GetDosPath( i, ofs->szPathName, len )) goto not_found;
 788         strcat( ofs->szPathName, "\\" );
 789         strcat( ofs->szPathName, name );
 790         if ((unixName = DOSFS_GetUnixFileName( ofs->szPathName, TRUE)) != NULL)
 791             break;
 792     }
 793
 794 found:
 795     dprintf_file( stddeb, "OpenFile: found '%s'\n", unixName );
 796     lstrcpyn32A(ofs->szPathName, DOSFS_GetDosTrueName( ofs->szPathName, FALSE),
 797                 sizeof(ofs->szPathName) );
 798
 799     if (mode & OF_DELETE)
 800     {
 801         if (unlink( unixName ) == -1) goto not_found;
 802         dprintf_file( stddeb, "OpenFile(%s): OF_DELETE return = OK\n", name);
 803         /* Return the handle, but close it first */
 804         FILE_FreeTaskHandle( hFileRet );
 805         return hFileRet;
 806     }
 807
 808     switch(mode & 3)
 809     {
 810     case OF_WRITE:
 811         unixMode = O_WRONLY; break;
 812     case OF_READWRITE:
 813         unixMode = O_RDWR; break;
 814     case OF_READ:
 815     default:
 816         unixMode = O_RDONLY; break;
 817     }
 818
 819     if (!(file = FILE_OpenUnixFile( unixName, unixMode ))) goto not_found;
 820     filedatetime[0] = file->filedate;
 821     filedatetime[1] = file->filetime;
 822     if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
 823     {
 824         if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
 825         {
 826             FILE_Close( file );
 827             dprintf_file( stddeb, "OpenFile(%s): OF_VERIFY failed\n", name );
 828             /* FIXME: what error here? */
 829             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 830             goto error;
 831         }
 832     }
 833     memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
 834
 835     if (mode & OF_EXIST)
 836     {
 837         FILE_Close( file );
 838         /* Return the handle, but close it first */
 839         FILE_FreeTaskHandle( hFileRet );
 840         return hFileRet;
 841     }
 842
 843 success:  /* We get here if the open was successful */
 844     dprintf_file( stddeb, "OpenFile(%s): OK, return = %d\n", name, hFileRet );
 845     FILE_SetTaskHandle( hFileRet, file );
 846     return hFileRet;
 847
 848 not_found:  /* We get here if the file does not exist */
 849     dprintf_file( stddeb, "OpenFile: '%s' not found\n", name );
 850     DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 851     /* fall through */
 852
 853 error:  /* We get here if there was an error opening the file */
 854     ofs->nErrCode = DOS_ExtendedError;
 855     dprintf_file( stddeb, "OpenFile(%s): return = HFILE_ERROR\n", name );
 856     FILE_FreeTaskHandle( hFileRet );
 857     return HFILE_ERROR;
 858 }
 859
 860
 861 /***********************************************************************
 862  *           _lclose   (KERNEL.81)
 863  */
 864 HFILE _lclose( HFILE hFile )
 865 {
 866     DOS_FILE *file;
 867
 868     dprintf_file( stddeb, "_lclose: handle %d\n", hFile );
 869     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR;
 870     FILE_Close( file );
 871     FILE_FreeTaskHandle( hFile );
 872     return 0;
 873 }
 874
 875
 876 /***********************************************************************
 877  *           _lread   (KERNEL.82)
 878  */
 879 INT _lread( HFILE hFile, SEGPTR buffer, WORD count )
 880 {
 881     return (INT)_hread( hFile, buffer, (LONG)count );
 882 }
 883
 884
 885 /***********************************************************************
 886  *           _lcreat   (KERNEL.83)
 887  */
 888 HFILE _lcreat( LPCSTR path, INT attr )
 889 {
 890     DOS_FILE *file;
 891     HFILE handle;
 892     int mode;
 893
 894     dprintf_file( stddeb, "_lcreat: %s %02x\n", path, attr );
 895     mode = (attr & 1) ? 0444 : 0666;
 896     if (!(file = FILE_Create( path, mode, FALSE ))) return HFILE_ERROR;
 897     if ((handle = FILE_AllocTaskHandle( file )) == HFILE_ERROR)
 898         FILE_Close( file );
 899     return handle;
 900 }
 901
 902
 903 /***********************************************************************
 904  *           _lcreat_uniq   (Not a Windows API)
 905  */
 906 HFILE _lcreat_uniq( LPCSTR path, INT attr )
 907 {
 908     DOS_FILE *file;
 909     HFILE handle;
 910     int mode;
 911
 912     dprintf_file( stddeb, "_lcreat: %s %02x\n", path, attr );
 913     mode = (attr & 1) ? 0444 : 0666;
 914     if (!(file = FILE_Create( path, mode, TRUE ))) return HFILE_ERROR;
 915     if ((handle = FILE_AllocTaskHandle( file )) == HFILE_ERROR)
 916         FILE_Close( file );
 917     return handle;
 918 }
 919
 920
 921 /***********************************************************************
 922  *           _llseek   (KERNEL.84)
 923  */
 924 LONG _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
 925 {
 926     DOS_FILE *file;
 927     int origin, result;
 928
 929     dprintf_file( stddeb, "_llseek: handle %d, offset %ld, origin %d\n",
 930                   hFile, lOffset, nOrigin);
 931
 932     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR;
 933     switch(nOrigin)
 934     {
 935         case 1:  origin = SEEK_CUR; break;
 936         case 2:  origin = SEEK_END; break;
 937         default: origin = SEEK_SET; break;
 938     }
 939
 940     if ((result = lseek( file->unix_handle, lOffset, origin )) == -1)
 941         FILE_SetDosError();
 942     return result;
 943 }
 944
 945
 946 /***********************************************************************
 947  *           _lopen   (KERNEL.85)
 948  */
 949 HFILE _lopen( LPCSTR path, INT mode )
 950 {
 951     DOS_FILE *file;
 952     int unixMode;
 953     HFILE handle;
 954
 955     dprintf_file(stddeb, "_lopen('%s',%04x)\n", path, mode );
 956
 957     switch(mode & 3)
 958     {
 959     case OF_WRITE:
 960         unixMode = O_WRONLY | O_TRUNC;
 961         break;
 962     case OF_READWRITE:
 963         unixMode = O_RDWR;
 964         break;
 965     case OF_READ:
 966     default:
 967         unixMode = O_RDONLY;
 968         break;
 969     }
 970     if (!(file = FILE_Open( path, unixMode ))) return HFILE_ERROR;
 971     if ((handle = FILE_AllocTaskHandle( file )) == HFILE_ERROR)
 972         FILE_Close( file );
 973     return handle;
 974 }
 975
 976
 977 /***********************************************************************
 978  *           _lwrite   (KERNEL.86)
 979  */
 980 INT _lwrite( HFILE hFile, LPCSTR buffer, WORD count )
 981 {
 982     return (INT)_hwrite( hFile, buffer, (LONG)count );
 983 }
 984
 985
 986 /***********************************************************************
 987  *           _hread   (KERNEL.349)
 988  */
 989 LONG _hread( HFILE hFile, SEGPTR buffer, LONG count )
 990 {
 991 #ifndef WINELIB
 992     LONG maxlen;
 993
 994     dprintf_file( stddeb, "_hread: %d %08lx %ld\n",
 995                   hFile, (DWORD)buffer, count );
 996
 997     /* Some programs pass a count larger than the allocated buffer */
 998     maxlen = GetSelectorLimit( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
 999     if (count > maxlen) count = maxlen;
1000 #endif
1001     return FILE_Read( hFile, PTR_SEG_TO_LIN(buffer), count );
1002 }
1003
1004
1005 /***********************************************************************
1006  *           _hwrite   (KERNEL.350)
1007  */
1008 LONG _hwrite( HFILE hFile, LPCSTR buffer, LONG count )
1009 {
1010     DOS_FILE *file;
1011     LONG result;
1012
1013     dprintf_file( stddeb, "_hwrite: %d %p %ld\n", hFile, buffer, count );
1014
1015     if (!(file = FILE_GetFile( hFile ))) return HFILE_ERROR;
1016
1017     if (count == 0)  /* Expand or truncate at current position */
1018         result = ftruncate( file->unix_handle,
1019                             lseek( file->unix_handle, 0, SEEK_CUR ) );
1020     else
1021         result = write( file->unix_handle, buffer, count );
1022
1023     if (result == -1) FILE_SetDosError();
1024     return result;
1025 }
1026
1027
1028 /***********************************************************************
1029  *           SetHandleCount   (KERNEL.199)
1030  */
1031 WORD SetHandleCount( WORD count )
1032 {
1033     HANDLE hPDB = GetCurrentPDB();
1034     PDB *pdb = (PDB *)GlobalLock16( hPDB );
1035     BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr );
1036     WORD i;
1037
1038     dprintf_file( stddeb, "SetHandleCount(%d)\n", count );
1039
1040     if (count < 20) count = 20;  /* No point in going below 20 */
1041     else if (count > 254) count = 254;
1042
1043     /* If shrinking the table, make sure all extra file handles are closed */
1044     if (count < pdb->nbFiles)
1045     {
1046         for (i = count; i < pdb->nbFiles; i++)
1047             if (files[i] != 0xff)  /* File open */
1048             {
1049                 DOS_ERROR( ER_TooManyOpenFiles, EC_ProgramError,
1050                            SA_Abort, EL_Disk );
1051                 return pdb->nbFiles;
1052             }
1053     }
1054
1055     if (count == 20)
1056     {
1057         if (pdb->nbFiles > 20)
1058         {
1059             memcpy( pdb->fileHandles, files, 20 );
1060 #ifdef WINELIB
1061             GlobalFree32( (HGLOBAL32)pdb->fileHandlesPtr );
1062             pdb->fileHandlesPtr = (SEGPTR)pdb->fileHandles;
1063 #else
1064             GlobalFree16( GlobalHandle16( SELECTOROF(pdb->fileHandlesPtr) ));
1065             pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18,
1066                                                    GlobalHandleToSel( hPDB ) );
1067 #endif
1068             pdb->nbFiles = 20;
1069         }
1070     }
1071     else  /* More than 20, need a new file handles table */
1072     {
1073         BYTE *newfiles;
1074 #ifdef WINELIB
1075         newfiles = (BYTE *)GlobalAlloc32( GMEM_FIXED, count );
1076 #else
1077         HANDLE newhandle = GlobalAlloc16( GMEM_MOVEABLE, count );
1078         if (!newhandle)
1079         {
1080             DOS_ERROR( ER_OutOfMemory, EC_OutOfResource, SA_Abort, EL_Memory );
1081             return pdb->nbFiles;
1082         }
1083         newfiles = (BYTE *)GlobalLock16( newhandle );
1084 #endif  /* WINELIB */
1085         if (count > pdb->nbFiles)
1086         {
1087             memcpy( newfiles, files, pdb->nbFiles );
1088             memset( newfiles + pdb->nbFiles, 0xff, count - pdb->nbFiles );
1089         }
1090         else memcpy( newfiles, files, count );
1091 #ifdef WINELIB
1092         if (pdb->nbFiles > 20) GlobalFree32( (HGLOBAL32)pdb->fileHandlesPtr );
1093         pdb->fileHandlesPtr = (SEGPTR)newfiles;
1094 #else
1095         if (pdb->nbFiles > 20)
1096             GlobalFree16( GlobalHandle16( SELECTOROF(pdb->fileHandlesPtr) ));
1097         pdb->fileHandlesPtr = WIN16_GlobalLock16( newhandle );
1098 #endif  /* WINELIB */
1099         pdb->nbFiles = count;
1100     }
1101     return pdb->nbFiles;
1102 }