files/file.c

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