git.oblomov.eu Git - wine/blob - dlls/kernel/file16.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * TODO:
  22  *    Fix the CopyFileEx methods to implement the "extended" functionality.
  23  *    Right now, they simply call the CopyFile method.
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <assert.h>
  32
  33 #define NONAMELESSUNION
  34 #define NONAMELESSSTRUCT
  35 #include "winerror.h"
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winreg.h"
  39 #include "winternl.h"
  40 #include "wine/winbase16.h"
  41 #include "wine/server.h"
  42
  43 #include "msdos.h"
  44 #include "kernel_private.h"
  45
  46 #include "wine/unicode.h"
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(file);
  50
  51 /***********************************************************************
  52  *           _hread16   (KERNEL.349)
  53  */
  54 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
  55 {
  56     return _lread( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
  57 }
  58
  59
  60 /***********************************************************************
  61  *           _hwrite   (KERNEL.350)
  62  */
  63 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
  64 {
  65     return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
  66 }
  67
  68
  69 /***********************************************************************
  70  *           _lcreat   (KERNEL.83)
  71  */
  72 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
  73 {
  74     return Win32HandleToDosFileHandle( (HANDLE)_lcreat( path, attr ) );
  75 }
  76
  77 /***********************************************************************
  78  *           _llseek   (KERNEL.84)
  79  *
  80  * FIXME:
  81  *   Seeking before the start of the file should be allowed for _llseek16,
  82  *   but cause subsequent I/O operations to fail (cf. interrupt list)
  83  *
  84  */
  85 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
  86 {
  87     return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
  88 }
  89
  90
  91 /***********************************************************************
  92  *           _lopen   (KERNEL.85)
  93  */
  94 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
  95 {
  96     return Win32HandleToDosFileHandle( (HANDLE)_lopen( path, mode ) );
  97 }
  98
  99
 100 /***********************************************************************
 101  *           _lread16   (KERNEL.82)
 102  */
 103 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
 104 {
 105     return (UINT16)_lread((HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
 106 }
 107
 108
 109 /***********************************************************************
 110  *           _lwrite   (KERNEL.86)
 111  */
 112 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
 113 {
 114     return (UINT16)_hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
 115 }
 116
 117 /***********************************************************************
 118  *           _hread (KERNEL.349)
 119  */
 120 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
 121 {
 122     LONG maxlen;
 123
 124     TRACE("%d %08lx %ld\n", hFile, (DWORD)buffer, count );
 125
 126     /* Some programs pass a count larger than the allocated buffer */
 127     maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
 128     if (count > maxlen) count = maxlen;
 129     return _lread((HFILE)DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
 130 }
 131
 132
 133 /***********************************************************************
 134  *           _lread (KERNEL.82)
 135  */
 136 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
 137 {
 138     return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
 139 }
 140
 141
 142 /***********************************************************************
 143  *           DeleteFile   (KERNEL.146)
 144  */
 145 BOOL16 WINAPI DeleteFile16( LPCSTR path )
 146 {
 147     return DeleteFileA( path );
 148 }
 149
 150 /**************************************************************************
 151  *           GetFileAttributes   (KERNEL.420)
 152  */
 153 DWORD WINAPI GetFileAttributes16( LPCSTR name )
 154 {
 155     return GetFileAttributesA( name );
 156 }
 157
 158
 159 /***********************************************************************
 160  *           GetTempFileName   (KERNEL.97)
 161  */
 162 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
 163                                  LPSTR buffer )
 164 {
 165     char temppath[MAX_PATH];
 166     char *prefix16 = NULL;
 167     UINT16 ret;
 168
 169     if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
 170     {
 171         GetCurrentDirectoryA(sizeof(temppath), temppath);
 172         drive |= temppath[0];
 173     }
 174
 175     if (drive & TF_FORCEDRIVE)
 176     {
 177         char    d[3];
 178
 179         d[0] = drive & ~TF_FORCEDRIVE;
 180         d[1] = ':';
 181         d[2] = '\0';
 182         if (GetDriveTypeA(d) == DRIVE_NO_ROOT_DIR)
 183         {
 184             drive &= ~TF_FORCEDRIVE;
 185             WARN("invalid drive %d specified\n", drive );
 186         }
 187     }
 188
 189     if (drive & TF_FORCEDRIVE)
 190         sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
 191     else
 192         GetTempPathA( MAX_PATH, temppath );
 193
 194     if (prefix)
 195     {
 196         prefix16 = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + 2);
 197         *prefix16 = '~';
 198         strcpy(prefix16 + 1, prefix);
 199     }
 200
 201     ret = GetTempFileNameA( temppath, prefix16, unique, buffer );
 202
 203     if (prefix16) HeapFree(GetProcessHeap(), 0, prefix16);
 204     return ret;
 205 }
 206
 207 /**************************************************************************
 208  *              SetFileAttributes       (KERNEL.421)
 209  */
 210 BOOL16 WINAPI SetFileAttributes16( LPCSTR lpFileName, DWORD attributes )
 211 {
 212     return SetFileAttributesA( lpFileName, attributes );
 213 }
 214
 215
 216 /***********************************************************************
 217  *           SetHandleCount   (KERNEL.199)
 218  */
 219 UINT16 WINAPI SetHandleCount16( UINT16 count )
 220 {
 221     return SetHandleCount( count );
 222 }
 223
 224
 225 /*************************************************************************
 226  *           FindFirstFile   (KERNEL.413)
 227  */
 228 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
 229 {
 230     HGLOBAL16 h16;
 231     HANDLE handle, *ptr;
 232
 233     if (!(h16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(handle) ))) return INVALID_HANDLE_VALUE16;
 234     ptr = GlobalLock16( h16 );
 235     *ptr = handle = FindFirstFileA( path, data );
 236     GlobalUnlock16( h16 );
 237
 238     if (handle == INVALID_HANDLE_VALUE)
 239     {
 240         GlobalFree16( h16 );
 241         h16 = INVALID_HANDLE_VALUE16;
 242     }
 243     return h16;
 244 }
 245
 246
 247 /*************************************************************************
 248  *           FindNextFile   (KERNEL.414)
 249  */
 250 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
 251 {
 252     HANDLE *ptr;
 253     BOOL ret = FALSE;
 254
 255     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
 256     {
 257         SetLastError( ERROR_INVALID_HANDLE );
 258         return ret;
 259     }
 260     ret = FindNextFileA( *ptr, data );
 261     GlobalUnlock16( handle );
 262     return ret;
 263 }
 264
 265
 266 /*************************************************************************
 267  *           FindClose   (KERNEL.415)
 268  */
 269 BOOL16 WINAPI FindClose16( HANDLE16 handle )
 270 {
 271     HANDLE *ptr;
 272
 273     if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))
 274     {
 275         SetLastError( ERROR_INVALID_HANDLE );
 276         return FALSE;
 277     }
 278     FindClose( *ptr );
 279     GlobalUnlock16( handle );
 280     GlobalFree16( handle );
 281     return TRUE;
 282 }