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