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 <stdlib.h>
   9 #include <unistd.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <sys/mman.h>
  13 #include <fcntl.h>
  14 #include <string.h>
  15 #include <time.h>
  16 #include "windows.h"
  17 #include "winbase.h"
  18 #include "winerror.h"
  19 #include "file.h"
  20 #include "process.h"
  21 #include "heap.h"
  22 #include "debug.h"
  23
  24 DWORD ErrnoToLastError(int errno_num);
  25
  26 static int TranslateCreationFlags(DWORD create_flags);
  27 static int TranslateAccessFlags(DWORD access_flags);
  28
  29 /***********************************************************************
  30  *             WriteFile               (KERNEL32.578)
  31  */
  32 BOOL32 WINAPI WriteFile(HANDLE32 hFile, LPCVOID lpBuffer,
  33                         DWORD numberOfBytesToWrite,
  34                         LPDWORD numberOfBytesWritten, LPOVERLAPPED lpOverlapped)
  35 {
  36         K32OBJ *ioptr;
  37         BOOL32 status = FALSE;
  38
  39         TRACE(file, "%d %p %ld\n", hFile, lpBuffer,
  40                      numberOfBytesToWrite);
  41
  42         if (!(ioptr = HANDLE_GetObjPtr( PROCESS_Current(), hFile,
  43                                         K32OBJ_UNKNOWN, 0 )))
  44                 return HFILE_ERROR32;
  45         if (K32OBJ_OPS(ioptr)->write)
  46             status = K32OBJ_OPS(ioptr)->write(ioptr, lpBuffer, numberOfBytesToWrite,
  47                                               numberOfBytesWritten, lpOverlapped);
  48         K32OBJ_DecCount( ioptr );
  49         return status;
  50 }
  51
  52 /***********************************************************************
  53  *              ReadFile                (KERNEL32.428)
  54  */
  55 BOOL32 WINAPI ReadFile(HANDLE32 hFile, LPVOID lpBuffer, DWORD numberOfBytesToRead,
  56                        LPDWORD numberOfBytesRead, LPOVERLAPPED lpOverlapped)
  57 {
  58         K32OBJ *ioptr;
  59         BOOL32 status = FALSE;
  60
  61         TRACE(file, "%d %p %ld\n", hFile, lpBuffer,
  62                      numberOfBytesToRead);
  63
  64         if (!(ioptr = HANDLE_GetObjPtr( PROCESS_Current(), hFile,
  65                                         K32OBJ_UNKNOWN, 0 )))
  66                 return HFILE_ERROR32;
  67         if (K32OBJ_OPS(ioptr)->read)
  68             status = K32OBJ_OPS(ioptr)->read(ioptr, lpBuffer, numberOfBytesToRead,
  69                                              numberOfBytesRead, lpOverlapped);
  70         K32OBJ_DecCount( ioptr );
  71         return status;
  72 }
  73
  74
  75 /***********************************************************************
  76  *              ReadFileEx                (KERNEL32.)
  77  */
  78 typedef
  79 VOID
  80 (WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)(
  81     DWORD dwErrorCode,
  82     DWORD dwNumberOfBytesTransfered,
  83     LPOVERLAPPED lpOverlapped
  84     );
  85
  86 BOOL32 WINAPI ReadFileEx(HFILE32 hFile, LPVOID lpBuffer, DWORD numtoread,
  87                          LPOVERLAPPED lpOverlapped,
  88                          LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  89 {
  90
  91     FIXME(file, "file %d to buf %p num %ld %p func %p stub\n",
  92           hFile, lpBuffer, numtoread, lpOverlapped, lpCompletionRoutine);
  93     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  94     return 0;
  95 }
  96
  97
  98 /*************************************************************************
  99  *              CreateFile32A              (KERNEL32.45)
 100  *
 101  * Doesn't support character devices, pipes, template files, or a
 102  * lot of the 'attributes' flags yet.
 103  */
 104 HFILE32 WINAPI CreateFile32A(LPCSTR filename, DWORD access, DWORD sharing,
 105                              LPSECURITY_ATTRIBUTES security, DWORD creation,
 106                              DWORD attributes, HANDLE32 template)
 107 {
 108     int access_flags, create_flags;
 109
 110     /* Translate the various flags to Unix-style.
 111      */
 112     access_flags = TranslateAccessFlags(access);
 113     create_flags = TranslateCreationFlags(creation);
 114
 115     if(template)
 116         FIXME(file, "template handles not supported.\n");
 117
 118     /* If the name starts with '\\?' or '\\.', ignore the first 3 chars.
 119      */
 120     if(!strncmp(filename, "\\\\?", 3) || !strncmp(filename, "\\\\.", 3))
 121         filename += 3;
 122
 123     /* If the name still starts with '\\', it's a UNC name.
 124      */
 125     if(!strncmp(filename, "\\\\", 2))
 126     {
 127         FIXME(file, "UNC names not supported.\n");
 128         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 129         return HFILE_ERROR32;
 130     }
 131
 132     /* If the name is either CONIN$ or CONOUT$, give them stdin
 133      * or stdout, respectively.
 134      */
 135     if(!strcmp(filename, "CONIN$")) return GetStdHandle( STD_INPUT_HANDLE );
 136     if(!strcmp(filename, "CONOUT$")) return GetStdHandle( STD_OUTPUT_HANDLE );
 137
 138     return FILE_Open( filename, access_flags | create_flags );
 139 }
 140
 141
 142 /*************************************************************************
 143  *              CreateFile32W              (KERNEL32.48)
 144  */
 145 HFILE32 WINAPI CreateFile32W(LPCWSTR filename, DWORD access, DWORD sharing,
 146                              LPSECURITY_ATTRIBUTES security, DWORD creation,
 147                              DWORD attributes, HANDLE32 template)
 148 {
 149     LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 150     HFILE32 res = CreateFile32A( afn, access, sharing, security, creation,
 151                                  attributes, template );
 152     HeapFree( GetProcessHeap(), 0, afn );
 153     return res;
 154 }
 155
 156 static int TranslateAccessFlags(DWORD access_flags)
 157 {
 158     int rc = 0;
 159
 160     switch(access_flags)
 161     {
 162         case GENERIC_READ:
 163             rc = O_RDONLY;
 164             break;
 165
 166         case GENERIC_WRITE:
 167             rc = O_WRONLY;
 168             break;
 169
 170         case (GENERIC_READ | GENERIC_WRITE):
 171             rc = O_RDWR;
 172             break;
 173     }
 174
 175     return rc;
 176 }
 177
 178 static int TranslateCreationFlags(DWORD create_flags)
 179 {
 180     int rc = 0;
 181
 182     switch(create_flags)
 183     {
 184         case CREATE_NEW:
 185             rc = O_CREAT | O_EXCL;
 186             break;
 187
 188         case CREATE_ALWAYS:
 189             rc = O_CREAT | O_TRUNC;
 190             break;
 191
 192         case OPEN_EXISTING:
 193             rc = 0;
 194             break;
 195
 196         case OPEN_ALWAYS:
 197             rc = O_CREAT;
 198             break;
 199
 200         case TRUNCATE_EXISTING:
 201             rc = O_TRUNC;
 202             break;
 203     }
 204
 205     return rc;
 206 }
 207
 208
 209 /**************************************************************************
 210  *              SetFileAttributes16     (KERNEL.421)
 211  */
 212 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
 213 {
 214     return SetFileAttributes32A( lpFileName, attributes );
 215 }
 216
 217
 218 /**************************************************************************
 219  *              SetFileAttributes32A    (KERNEL32.490)
 220  */
 221 BOOL32 WINAPI SetFileAttributes32A(LPCSTR lpFileName, DWORD attributes)
 222 {
 223     struct stat buf;
 224     DOS_FULL_NAME full_name;
 225
 226     if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name ))
 227         return FALSE;
 228
 229     TRACE(file,"(%s,%lx)\n",lpFileName,attributes);
 230     if (attributes & FILE_ATTRIBUTE_NORMAL) {
 231       attributes &= ~FILE_ATTRIBUTE_NORMAL;
 232       if (attributes)
 233         FIXME(file,"(%s):%lx illegal combination with FILE_ATTRIBUTE_NORMAL.\n",
 234               lpFileName,attributes);
 235     }
 236     if(stat(full_name.long_name,&buf)==-1)
 237     {
 238         SetLastError(ErrnoToLastError(errno));
 239         return FALSE;
 240     }
 241     if (attributes & FILE_ATTRIBUTE_READONLY)
 242     {
 243         buf.st_mode &= ~0222; /* octal!, clear write permission bits */
 244         attributes &= ~FILE_ATTRIBUTE_READONLY;
 245     }
 246     attributes &= ~(FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
 247     if (attributes)
 248         FIXME(file,"(%s):%lx attribute(s) not implemented.\n",
 249               lpFileName,attributes);
 250     if (-1==chmod(full_name.long_name,buf.st_mode))
 251     {
 252         SetLastError(ErrnoToLastError(errno));
 253         return FALSE;
 254     }
 255     return TRUE;
 256 }
 257
 258
 259 /**************************************************************************
 260  *              SetFileAttributes32W    (KERNEL32.491)
 261  */
 262 BOOL32 WINAPI SetFileAttributes32W(LPCWSTR lpFileName, DWORD attributes)
 263 {
 264     LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
 265     BOOL32 res = SetFileAttributes32A( afn, attributes );
 266     HeapFree( GetProcessHeap(), 0, afn );
 267     return res;
 268 }
 269
 270
 271 /**************************************************************************
 272  *              SetFileApisToOEM   (KERNEL32.645)
 273  */
 274 VOID WINAPI SetFileApisToOEM(void)
 275 {
 276   /*FIXME(file,"(): stub!\n");*/
 277 }
 278
 279
 280 /**************************************************************************
 281  *              SetFileApisToANSI   (KERNEL32.644)
 282  */
 283 VOID WINAPI SetFileApisToANSI(void)
 284 {
 285     /*FIXME(file,"(): stub\n");*/
 286 }
 287
 288
 289 /******************************************************************************
 290  * AreFileApisANSI [KERNEL32.105]  Determines if file functions are using ANSI
 291  *
 292  * RETURNS
 293  *    TRUE:  Set of file functions is using ANSI code page
 294  *    FALSE: Set of file functions is using OEM code page
 295  */
 296 BOOL32 WINAPI AreFileApisANSI(void)
 297 {
 298     FIXME(file,"(void): stub\n");
 299     return TRUE;
 300 }
 301