win32/file.c

   1 /*
   2  * Win32 kernel functions
   3  *
   4  * Copyright 1995 Martin von Loewis, Sven Verdoolaege, and Cameron Heide
   5  */
   6
   7 #include <errno.h>
   8 #include <sys/errno.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <sys/mman.h>
  14 #include <fcntl.h>
  15 #include <string.h>
  16 #include <time.h>
  17 #include "windows.h"
  18 #include "winbase.h"
  19 #include "winerror.h"
  20 #include "file.h"
  21 #include "device.h"
  22 #include "process.h"
  23 #include "heap.h"
  24 #include "debug.h"
  25
  26 DWORD ErrnoToLastError(int errno_num);
  27
  28 static int TranslateCreationFlags(DWORD create_flags);
  29 static int TranslateAccessFlags(DWORD access_flags);
  30 static int TranslateShareFlags(DWORD share_flags);
  31
  32 /***********************************************************************
  33  *              ReadFileEx                (KERNEL32.)
  34  */
  35 typedef
  36 VOID
  37 (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(
  38     DWORD dwErrorCode,
  39     DWORD dwNumberOfBytesTransfered,
  40     LPOVERLAPPED lpOverlapped
  41     );
  42
  43 BOOL32 WINAPI ReadFileEx(HFILE32 hFile, LPVOID lpBuffer, DWORD numtoread,
  44                          LPOVERLAPPED lpOverlapped,
  45                          LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  46 {
  47
  48     FIXME(file, "file %d to buf %p num %ld %p func %p stub\n",
  49           hFile, lpBuffer, numtoread, lpOverlapped, lpCompletionRoutine);
  50     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  51     return 0;
  52 }
  53
  54
  55 /*************************************************************************
  56  * CreateFile32A [KERNEL32.45]  Creates or opens a file or other object
  57  *
  58  * Creates or opens an object, and returns a handle that can be used to
  59  * access that object.
  60  *
  61  * PARAMS
  62  *
  63  * filename     [I] pointer to filename to be accessed
  64  * access       [I] access mode requested
  65  * sharing      [I] share mode
  66  * security     [I] pointer to security attributes
  67  * creation     [I] ?
  68  * attributes   [I] ?
  69  * template     [I] handle to file with attributes to copy
  70  *
  71  * RETURNS
  72  *   Success: Open handle to specified file
  73  *   Failure: INVALID_HANDLE_VALUE
  74  *
  75  * NOTES
  76  *  Should call SetLastError() on failure.
  77  *
  78  * BUGS
  79  *
  80  * Doesn't support character devices, pipes, template files, or a
  81  * lot of the 'attributes' flags yet.
  82  */
  83 HFILE32 WINAPI CreateFile32A(LPCSTR filename, DWORD access, DWORD sharing,
  84                              LPSECURITY_ATTRIBUTES security, DWORD creation,
  85                              DWORD attributes, HANDLE32 template)
  86 {
  87     int access_flags, create_flags, share_flags;
  88     HFILE32 to_dup = HFILE_ERROR32; /* handle to dup */
  89
  90     /* Translate the various flags to Unix-style.
  91      */
  92     access_flags = TranslateAccessFlags(access);
  93     create_flags = TranslateCreationFlags(creation);
  94     share_flags = TranslateShareFlags(sharing);
  95
  96     if(template)
  97         FIXME(file, "template handles not supported.\n");
  98
  99     if(!filename)
 100       return HFILE_ERROR32;
 101     /* If the name starts with '\\?\' or '\\.\', ignore the first 4 chars.
 102      */
 103     if(!strncmp(filename, "\\\\?\\", 4) || !strncmp(filename, "\\\\.\\", 4))
 104     {
 105         if (filename[2] == '.')
 106             return DEVICE_Open( filename+4, access_flags | create_flags );
 107
 108         filename += 4;
 109         if (!strncmp(filename, "UNC", 3))
 110         {
 111             FIXME(file, "UNC name (%s) not supported.\n",filename);
 112             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 113             return HFILE_ERROR32;
 114         }
 115     }
 116
 117     /* If the name still starts with '\\', it's a UNC name.
 118      */
 119     if(!strncmp(filename, "\\\\", 2))
 120     {
 121         FIXME(file, "UNC names not supported.\n");
 122         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 123         return HFILE_ERROR32;
 124     }
 125
 126     /* If the name is either CONIN$ or CONOUT$, give them duplicated stdin
 127      * or stdout, respectively. The lower case version is also allowed. Most likely
 128      * this should be a case ignore string compare.
 129      */
 130     if(!strcasecmp(filename, "CONIN$"))
 131         to_dup = GetStdHandle( STD_INPUT_HANDLE );
 132     else if(!strcasecmp(filename, "CONOUT$"))
 133         to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
 134
 135     if(to_dup != HFILE_ERROR32)
 136     {
 137         HFILE32 handle;
 138         if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
 139                               &handle, access, FALSE, 0 ))
 140             handle = HFILE_ERROR32;
 141         return handle;
 142     }
 143     return FILE_Open( filename, access_flags | create_flags,share_flags );
 144 }
 145
 146
 147 /*************************************************************************
 148  *              CreateFile32W              (KERNEL32.48)
 149  */
 150 HFILE32 WINAPI CreateFile32W(LPCWSTR filename, DWORD access, DWORD sharing,
 151                              LPSECURITY_ATTRIBUTES security, DWORD creation,
 152                              DWORD attributes, HANDLE32 template)
 153 {
 154     LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 155     HFILE32 res = CreateFile32A( afn, access, sharing, security, creation,
 156                                  attributes, template );
 157     HeapFree( GetProcessHeap(), 0, afn );
 158     return res;
 159 }
 160
 161 static int TranslateAccessFlags(DWORD access_flags)
 162 {
 163     int rc = 0;
 164
 165     switch(access_flags)
 166     {
 167         case GENERIC_READ:
 168             rc = O_RDONLY;
 169             break;
 170
 171         case GENERIC_WRITE:
 172             rc = O_WRONLY;
 173             break;
 174
 175         case (GENERIC_READ | GENERIC_WRITE):
 176             rc = O_RDWR;
 177             break;
 178     }
 179
 180     return rc;
 181 }
 182
 183 static int TranslateCreationFlags(DWORD create_flags)
 184 {
 185     int rc = 0;
 186
 187     switch(create_flags)
 188     {
 189         case CREATE_NEW:
 190             rc = O_CREAT | O_EXCL;
 191             break;
 192
 193         case CREATE_ALWAYS:
 194             rc = O_CREAT | O_TRUNC;
 195             break;
 196
 197         case OPEN_EXISTING:
 198             rc = 0;
 199             break;
 200
 201         case OPEN_ALWAYS:
 202             rc = O_CREAT;
 203             break;
 204
 205         case TRUNCATE_EXISTING:
 206             rc = O_TRUNC;
 207             break;
 208     }
 209
 210     return rc;
 211 }
 212 static int TranslateShareFlags(DWORD share_flags)
 213 /*
 214 OPEN_SHARE_DENYNONE     FILE_SHARE_READ | FILE_SHARE_WRITE
 215 OPEN_SHARE_DENYREAD     FILE_SHARE_WRITE
 216 OPEN_SHARE_DENYREADWRITE        0
 217 OPEN_SHARE_DENYWRITE    FILE_SHARE_READ
 218 */
 219 {
 220   switch(share_flags)
 221     {
 222     case FILE_SHARE_READ | FILE_SHARE_WRITE:
 223       return OF_SHARE_DENY_NONE;
 224     case FILE_SHARE_WRITE:
 225       return OF_SHARE_DENY_READ;
 226     case FILE_SHARE_READ:
 227       return OF_SHARE_DENY_WRITE;
 228     case 0:
 229       return OF_SHARE_EXCLUSIVE;
 230     default:
 231     }
 232   FIXME(file,"unknown sharing flags 0x%04lx\n",share_flags);
 233   return OF_SHARE_EXCLUSIVE;
 234 }
 235 /**************************************************************************
 236  *              SetFileAttributes16     (KERNEL.421)
 237  */
 238 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
 239 {
 240     return SetFileAttributes32A( lpFileName, attributes );
 241 }
 242
 243
 244 /**************************************************************************
 245  *              SetFileAttributes32A    (KERNEL32.490)
 246  */
 247 BOOL32 WINAPI SetFileAttributes32A(LPCSTR lpFileName, DWORD attributes)
 248 {
 249     struct stat buf;
 250     DOS_FULL_NAME full_name;
 251
 252     if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
 253         return FALSE;
 254
 255     TRACE(file,"(%s,%lx)\n",lpFileName,attributes);
 256     if (attributes & FILE_ATTRIBUTE_NORMAL) {
 257       attributes &= ~FILE_ATTRIBUTE_NORMAL;
 258       if (attributes)
 259         FIXME(file,"(%s):%lx illegal combination with FILE_ATTRIBUTE_NORMAL.\n",
 260               lpFileName,attributes);
 261     }
 262     if(stat(full_name.long_name,&buf)==-1)
 263     {
 264         SetLastError(ErrnoToLastError(errno));
 265         return FALSE;
 266     }
 267     if (attributes & FILE_ATTRIBUTE_READONLY)
 268     {
 269         buf.st_mode &= ~0222; /* octal!, clear write permission bits */
 270         attributes &= ~FILE_ATTRIBUTE_READONLY;
 271     }
 272     attributes &= ~(FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
 273     if (attributes)
 274         FIXME(file,"(%s):%lx attribute(s) not implemented.\n",
 275               lpFileName,attributes);
 276     if (-1==chmod(full_name.long_name,buf.st_mode))
 277     {
 278         SetLastError(ErrnoToLastError(errno));
 279         return FALSE;
 280     }
 281     return TRUE;
 282 }
 283
 284
 285 /**************************************************************************
 286  *              SetFileAttributes32W    (KERNEL32.491)
 287  */
 288 BOOL32 WINAPI SetFileAttributes32W(LPCWSTR lpFileName, DWORD attributes)
 289 {
 290     LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
 291     BOOL32 res = SetFileAttributes32A( afn, attributes );
 292     HeapFree( GetProcessHeap(), 0, afn );
 293     return res;
 294 }
 295
 296
 297 /**************************************************************************
 298  *              SetFileApisToOEM   (KERNEL32.645)
 299  */
 300 VOID WINAPI SetFileApisToOEM(void)
 301 {
 302   /*FIXME(file,"(): stub!\n");*/
 303 }
 304
 305
 306 /**************************************************************************
 307  *              SetFileApisToANSI   (KERNEL32.644)
 308  */
 309 VOID WINAPI SetFileApisToANSI(void)
 310 {
 311     /*FIXME(file,"(): stub\n");*/
 312 }
 313
 314
 315 /******************************************************************************
 316  * AreFileApisANSI [KERNEL32.105]  Determines if file functions are using ANSI
 317  *
 318  * RETURNS
 319  *    TRUE:  Set of file functions is using ANSI code page
 320  *    FALSE: Set of file functions is using OEM code page
 321  */
 322 BOOL32 WINAPI AreFileApisANSI(void)
 323 {
 324     FIXME(file,"(void): stub\n");
 325     return TRUE;
 326 }
 327