misc/file.c

   1 /************************************************************************
   2  * FILE.C     Copyright (C) 1993 John Burton
   3  *
   4  * File I/O routines for the Linux Wine Project.
   5  *
   6  * WARNING : Many options of OpenFile are not yet implemeted.
   7  *
   8  * NOV 93 Erik Bos (erik@(trashcan.)hacktic.nl
   9  *              - removed ParseDosFileName, and DosDrive structures.
  10  *              - structures dynamically configured at runtime.
  11  *              - _lopen modified to use GetUnixFileName.
  12  *
  13  * DEC 93 Erik Bos (erik@(trashcan.)hacktic.nl)
  14  *              - Existing functions modified to use dosfs functions.
  15  *              - Added _llseek, _lcreat, GetDriveType, GetTempDrive,
  16  *                GetWindowsDirectory, GetSystemDirectory, GetTempFileName.
  17  *
  18  ************************************************************************/
  19
  20 #include <stdio.h>
  21 #include <fcntl.h>
  22 #include <limits.h>
  23 #include <unistd.h>
  24 #include <time.h>
  25 #include <windows.h>
  26 #include "prototypes.h"
  27
  28 /* #define DEBUG_FILE /* */
  29
  30 char WindowsDirectory[256], SystemDirectory[256], TempDirectory[256];
  31 extern char WindowsPath[256];
  32
  33 /***************************************************************************
  34  _lopen
  35
  36  Emulate the _lopen windows call
  37  ***************************************************************************/
  38 INT _lopen (LPSTR lpPathName, INT iReadWrite)
  39 {
  40   int  handle;
  41   char *UnixFileName;
  42
  43 #ifdef DEBUG_FILE
  44   fprintf (stderr, "_lopen: open('%s', %X);\n", lpPathName, iReadWrite);
  45 #endif
  46
  47   if ((UnixFileName = GetUnixFileName(lpPathName)) == NULL)
  48         return HFILE_ERROR;
  49   iReadWrite &= 0x000F;
  50   handle =  open (UnixFileName, iReadWrite);
  51
  52 #ifdef DEBUG_FILE
  53   fprintf (stderr, "_lopen: open: %s (handle %d)\n", UnixFileName, handle);
  54 #endif
  55
  56   if (handle == -1)
  57         return HFILE_ERROR;
  58   else
  59         return handle;
  60 }
  61
  62 /***************************************************************************
  63  _lread
  64  ***************************************************************************/
  65 INT _lread (INT hFile, LPSTR lpBuffer, WORD wBytes)
  66 {
  67   int result;
  68
  69 #ifdef DEBUG_FILE
  70   fprintf(stderr, "_lread: handle %d, buffer = %ld, length = %d\n",
  71                         hFile, (int) lpBuffer, wBytes);
  72 #endif
  73
  74   result = read (hFile, lpBuffer, wBytes);
  75
  76   if (result == -1)
  77         return HFILE_ERROR;
  78   else
  79         return result;
  80 }
  81
  82 /****************************************************************************
  83  _lwrite
  84 ****************************************************************************/
  85 INT _lwrite (INT hFile, LPSTR lpBuffer, WORD wBytes)
  86 {
  87         int result;
  88
  89 #if 0
  90 #ifdef DEBUG_FILE
  91   fprintf(stderr, "_lwrite: handle %d, buffer = %ld, length = %d\n",
  92                         hFile, (int) lpBuffer, wBytes);
  93 #endif
  94 #endif
  95         result = write (hFile, lpBuffer, wBytes);
  96
  97         if (result == -1)
  98                 return HFILE_ERROR;
  99         else
 100                 return result;
 101 }
 102
 103 /***************************************************************************
 104  _lclose
 105  ***************************************************************************/
 106 INT _lclose (INT hFile)
 107 {
 108 #ifdef DEBUG_FILE
 109         fprintf(stderr, "_lclose: handle %d\n", hFile);
 110 #endif
 111         if (close (hFile))
 112                 return HFILE_ERROR;
 113         else
 114                 return 0;
 115 }
 116
 117 /**************************************************************************
 118  OpenFile
 119
 120  Warning:  This is nearly totally untested.  It compiles, that's it...
 121                                             -SL 9/13/93
 122  **************************************************************************/
 123 INT OpenFile (LPSTR lpFileName, LPOFSTRUCT ofs, WORD wStyle)
 124 {
 125     int         base, flags;
 126     int         handle;
 127         char    buf[256];
 128
 129 #ifdef DEBUG_FILE
 130     fprintf(stderr,"OpenFile(%s,<struct>,%04X)\n",lpFileName,wStyle);
 131 #endif
 132
 133     base   = wStyle & 0xF;
 134     flags  = wStyle & 0xFFF0;
 135
 136     flags &= 0xFF0F;  /* strip SHARE bits for now */
 137     flags &= 0xD7FF;  /* strip PROMPT & CANCEL bits for now */
 138     flags &= 0x7FFF;  /* strip REOPEN bit for now */
 139     flags &= 0xFBFF;  /* strib VERIFY bit for now */
 140
 141     if (flags & OF_CREATE)
 142     {
 143         base  |= O_CREAT;
 144         flags &= 0xEFFF;
 145     }
 146
 147 #ifdef DEBUG_FILE
 148     fprintf(stderr,"now %d,%d\n",base,flags);
 149 #endif
 150
 151     if (flags & OF_EXIST)
 152     {
 153         printf("OpenFile // OF_EXIST '%s' !\n", lpFileName);
 154         handle = _lopen (lpFileName, wStyle);
 155         if (handle == -1) {
 156                 /* Try again with WindowsPath */
 157                 if (FindFile(buf, sizeof(buf), lpFileName, NULL, WindowsPath) != NULL) {
 158                         handle = _lopen (buf, wStyle);
 159                         }
 160                 }
 161         close(handle);
 162         return handle;
 163     }
 164     if (flags & OF_DELETE)
 165     {
 166         printf("OpenFile // OF_DELETE '%s' !\n", lpFileName);
 167         return unlink(lpFileName);
 168     }
 169     else
 170     {
 171         int     handle;
 172         char    *UnixFileName;
 173         if ((UnixFileName = GetUnixFileName(lpFileName)) == NULL)
 174             return HFILE_ERROR;
 175         handle = open(UnixFileName, base, 0666);
 176         if (handle == -1) {
 177                 /* Try again with WindowsPath */
 178                 if (FindFile(buf, sizeof(buf), lpFileName, NULL, WindowsPath) != NULL) {
 179 #ifdef DEBUG_FILE
 180                         printf("OpenFile // file '%s' found !\n", buf);
 181 #endif
 182                         UnixFileName = buf;
 183                         handle = open(UnixFileName, base, 0666);
 184                         }
 185                 }
 186
 187 #ifdef DEBUG_FILE
 188         fprintf(stderr, "OpenFile: returning %04.4x\n", handle);
 189 #endif
 190
 191         if (handle == -1)
 192             return HFILE_ERROR;
 193         else
 194             return handle;
 195     }
 196 }
 197
 198 /**************************************************************************
 199  SetHandleCount
 200
 201  Changes the number of file handles available to the application.  Since
 202  Linux isn't limited to 20 files, this one's easy. - SL
 203  **************************************************************************/
 204
 205 #if !defined (OPEN_MAX)
 206 /* This one is for the Sun */
 207 #define OPEN_MAX _POSIX_OPEN_MAX
 208 #endif
 209 WORD SetHandleCount (WORD wNumber)
 210 {
 211   printf("SetHandleCount(%d)\n",wNumber);
 212   return((wNumber<OPEN_MAX) ? wNumber : OPEN_MAX);
 213 }
 214
 215 /***************************************************************************
 216  _llseek
 217  ***************************************************************************/
 218 LONG _llseek (INT hFile, LONG lOffset, INT nOrigin)
 219 {
 220         int origin;
 221
 222 #ifdef DEBUG_FILE
 223   fprintf(stderr, "_llseek: handle %d, offset %ld, origin %d\n", hFile, lOffset, nOrigin);
 224 #endif
 225
 226         switch (nOrigin) {
 227                 case 1: origin = SEEK_CUR;
 228                         break;
 229                 case 2: origin = SEEK_END;
 230                         break;
 231                 default: origin = SEEK_SET;
 232                         break;
 233                 }
 234
 235         return ( lseek(hFile, lOffset, origin) );
 236 }
 237
 238 /***************************************************************************
 239  _lcreat
 240  ***************************************************************************/
 241 INT _lcreat (LPSTR lpszFilename, INT fnAttribute)
 242 {
 243         int handle;
 244         char *UnixFileName;
 245
 246 #ifdef DEBUG_FILE
 247         fprintf(stderr, "_lcreat: filename %s, attributes %d\n",lpszFilename,
 248                         fnAttribute);
 249 #endif
 250         if ((UnixFileName = GetUnixFileName(lpszFilename)) == NULL)
 251                 return HFILE_ERROR;
 252         handle =  open (UnixFileName, O_CREAT | O_TRUNC | O_WRONLY, 426);
 253
 254         if (handle == -1)
 255                 return HFILE_ERROR;
 256         else
 257                 return handle;
 258 }
 259
 260 /***************************************************************************
 261  GetDriveType
 262  ***************************************************************************/
 263 UINT GetDriveType(INT drive)
 264 {
 265
 266 #ifdef DEBUG_FILE
 267         fprintf(stderr,"GetDriveType %c:\n",'A'+drive);
 268 #endif
 269
 270         if (!DOS_ValidDrive(drive))
 271                 return DRIVE_DOESNOTEXIST;
 272
 273         if (drive == 0 || drive == 1)
 274                 return DRIVE_REMOVABLE;
 275
 276         return DRIVE_FIXED;
 277 }
 278
 279 /***************************************************************************
 280  GetTempDrive
 281  ***************************************************************************/
 282 BYTE GetTempDrive(BYTE chDriveLetter)
 283 {
 284 #ifdef DEBUG_FILE
 285         fprintf(stderr,"GetTempDrive (%d)\n",chDriveLetter);
 286 #endif
 287         return('C');
 288 }
 289
 290 /***************************************************************************
 291  GetWindowsDirectory
 292  ***************************************************************************/
 293 UINT GetWindowsDirectory(LPSTR lpszSysPath, UINT cbSysPath)
 294 {
 295         if (cbSysPath < strlen(WindowsDirectory))
 296                 *lpszSysPath = 0;
 297         else
 298                 strcpy(lpszSysPath, WindowsDirectory);
 299
 300 #ifdef DEBUG_FILE
 301         fprintf(stderr,"GetWindowsDirectory (%s)\n",lpszSysPath);
 302 #endif
 303
 304         ChopOffSlash(lpszSysPath);
 305         return(strlen(lpszSysPath));
 306 }
 307 /***************************************************************************
 308  GetSystemDirectory
 309  ***************************************************************************/
 310 UINT GetSystemDirectory(LPSTR lpszSysPath, UINT cbSysPath)
 311 {
 312         if (cbSysPath < strlen(SystemDirectory))
 313                 *lpszSysPath = 0;
 314         else
 315                 strcpy(lpszSysPath, SystemDirectory);
 316
 317 #ifdef DEBUG_FILE
 318         fprintf(stderr,"GetSystemDirectory (%s)\n",lpszSysPath);
 319 #endif
 320
 321         ChopOffSlash(lpszSysPath);
 322         return(strlen(lpszSysPath));
 323 }
 324 /***************************************************************************
 325  GetTempFileName
 326  ***************************************************************************/
 327 INT GetTempFileName(BYTE bDriveLetter, LPCSTR lpszPrefixString, UINT uUnique, LPSTR lpszTempFileName)
 328 {
 329         int unique;
 330         int handle;
 331         char tempname[256];
 332
 333         if (uUnique == 0)
 334                 unique = time(NULL)%99999L;
 335         else
 336                 unique = uUnique%99999L;
 337
 338         strcpy(tempname,lpszPrefixString);
 339         tempname[3]='\0';
 340
 341         sprintf(lpszTempFileName,"%s\\%s%d.tmp", TempDirectory, tempname,
 342                 unique);
 343
 344         ToDos(lpszTempFileName);
 345
 346 #ifdef DEBUG_FILE
 347         fprintf(stderr,"GetTempFilename: %c %s %d => %s\n",bDriveLetter,
 348                 lpszPrefixString,uUnique,lpszTempFileName);
 349 #endif
 350         if ((handle = _lcreat (lpszTempFileName, 0x0000)) == -1) {
 351                 fprintf(stderr,"GetTempFilename: can't create temp file '%s' !\n", lpszTempFileName);
 352                 }
 353         else
 354                 close(handle);
 355
 356         return unique;
 357 }
 358
 359 /***************************************************************************
 360  SetErrorMode
 361  ***************************************************************************/
 362 WORD SetErrorMode(WORD x)
 363 {
 364         fprintf(stderr,"wine: SetErrorMode %4x (ignored)\n",x);
 365 }
 366
 367 /***************************************************************************
 368  _hread
 369  ***************************************************************************/
 370 long _hread(int hf, void FAR *hpvBuffer, long cbBuffer)
 371 {
 372         return read(hf, hpvBuffer, cbBuffer);
 373 }
 374 /***************************************************************************
 375  _hwrite
 376  ***************************************************************************/
 377 long _hwrite(int hf, const void FAR *hpvBuffer, long cbBuffer)
 378 {
 379         return write(hf, hpvBuffer, cbBuffer);
 380 }