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