reactos/lib/kernel32/file/rw.c

   1 /* $Id: rw.c,v 1.11 2000/04/03 21:54:35 dwelch Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/file/rw.c
   6  * PURPOSE:         Read/write functions
   7  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   8  * UPDATE HISTORY:
   9  *                  Created 01/11/98
  10  */
  11
  12 /* INCLUDES ****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15 #include <windows.h>
  16 #include <wchar.h>
  17 #include <string.h>
  18
  19 #define NDEBUG
  20 #include <kernel32/kernel32.h>
  21
  22
  23 /* FUNCTIONS ****************************************************************/
  24
  25 WINBOOL STDCALL WriteFile(HANDLE hFile,
  26                           LPCVOID lpBuffer,
  27                           DWORD nNumberOfBytesToWrite,
  28                           LPDWORD lpNumberOfBytesWritten,
  29                           LPOVERLAPPED lpOverLapped)
  30 {
  31    HANDLE hEvent = NULL;
  32    LARGE_INTEGER Offset;
  33    NTSTATUS errCode;
  34    IO_STATUS_BLOCK IIosb;
  35    PIO_STATUS_BLOCK IoStatusBlock;
  36    PLARGE_INTEGER ptrOffset;
  37
  38    DPRINT("WriteFile(hFile %x)\n",hFile);
  39
  40    if (IsConsoleHandle(hFile))
  41      {
  42         return(WriteConsoleA(hFile,
  43                              lpBuffer,
  44                              nNumberOfBytesToWrite,
  45                              lpNumberOfBytesWritten,
  46                              NULL));
  47      }
  48
  49    if (lpOverLapped != NULL)
  50      {
  51         Offset.u.LowPart = lpOverLapped->Offset;
  52         Offset.u.HighPart = lpOverLapped->OffsetHigh;
  53         lpOverLapped->Internal = STATUS_PENDING;
  54         hEvent = lpOverLapped->hEvent;
  55         IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
  56         ptrOffset = &Offset;
  57      }
  58    else
  59      {
  60         ptrOffset = NULL;
  61         IoStatusBlock = &IIosb;
  62         Offset.QuadPart = 0;
  63      }
  64
  65    errCode = NtWriteFile(hFile,
  66                          hEvent,
  67                          NULL,
  68                          NULL,
  69                          IoStatusBlock,
  70                          (PVOID)lpBuffer,
  71                          nNumberOfBytesToWrite,
  72                          ptrOffset,
  73                          NULL);
  74    if (!NT_SUCCESS(errCode))
  75      {
  76         SetLastError(RtlNtStatusToDosError(errCode));
  77         DPRINT("WriteFile() failed\n");
  78         return FALSE;
  79      }
  80    if (lpNumberOfBytesWritten != NULL )
  81      {
  82         *lpNumberOfBytesWritten = IoStatusBlock->Information;
  83      }
  84    DPRINT("WriteFile() succeeded\n");
  85    return(TRUE);
  86 }
  87
  88
  89
  90 WINBOOL STDCALL ReadFile(HANDLE hFile,
  91                          LPVOID lpBuffer,
  92                          DWORD nNumberOfBytesToRead,
  93                          LPDWORD lpNumberOfBytesRead,
  94                          LPOVERLAPPED lpOverLapped)
  95 {
  96    HANDLE hEvent = NULL;
  97    LARGE_INTEGER Offset;
  98    NTSTATUS errCode;
  99    IO_STATUS_BLOCK IIosb;
 100    PIO_STATUS_BLOCK IoStatusBlock;
 101    PLARGE_INTEGER ptrOffset;
 102
 103    DbgPrint("ReadFile(hFile %x)\n", hFile);
 104
 105    if (IsConsoleHandle(hFile))
 106      {
 107         return(ReadConsoleA(hFile,
 108                             lpBuffer,
 109                             nNumberOfBytesToRead,
 110                             lpNumberOfBytesRead,
 111                             NULL));
 112      }
 113
 114    if (lpOverLapped != NULL)
 115      {
 116         Offset.u.LowPart = lpOverLapped->Offset;
 117         Offset.u.HighPart = lpOverLapped->OffsetHigh;
 118         lpOverLapped->Internal = STATUS_PENDING;
 119         hEvent = lpOverLapped->hEvent;
 120         IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
 121         ptrOffset = &Offset;
 122      }
 123    else
 124      {
 125         ptrOffset = NULL;
 126         IoStatusBlock = &IIosb;
 127      }
 128
 129    errCode = NtReadFile(hFile,
 130                         hEvent,
 131                         NULL,
 132                         NULL,
 133                         IoStatusBlock,
 134                         lpBuffer,
 135                         nNumberOfBytesToRead,
 136                         ptrOffset,
 137                         NULL);
 138
 139    if (errCode != STATUS_PENDING && lpNumberOfBytesRead != NULL)
 140      {
 141         *lpNumberOfBytesRead = IoStatusBlock->Information;
 142      }
 143
 144    if (!NT_SUCCESS(errCode))
 145      {
 146         SetLastError(RtlNtStatusToDosError(errCode));
 147         return(FALSE);
 148      }
 149    return(TRUE);
 150 }
 151
 152 VOID ApcRoutine(PVOID ApcContext,
 153                 struct _IO_STATUS_BLOCK* IoStatusBlock,
 154                 ULONG NumberOfBytesTransfered)
 155 {
 156    DWORD dwErrorCode;
 157    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine =
 158      (LPOVERLAPPED_COMPLETION_ROUTINE)ApcContext;
 159
 160    dwErrorCode = RtlNtStatusToDosError( IoStatusBlock->Status);
 161    lpCompletionRoutine(dwErrorCode,
 162                        NumberOfBytesTransfered,
 163                        (LPOVERLAPPED)IoStatusBlock);
 164 }
 165
 166
 167 WINBOOL
 168 STDCALL
 169 WriteFileEx (
 170         HANDLE                          hFile,
 171         LPCVOID                         lpBuffer,
 172         DWORD                           nNumberOfBytesToWrite,
 173         LPOVERLAPPED                    lpOverLapped,
 174         LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
 175         )
 176 {
 177
 178    LARGE_INTEGER Offset;
 179    NTSTATUS errCode;
 180    PIO_STATUS_BLOCK IoStatusBlock;
 181    PLARGE_INTEGER ptrOffset;
 182
 183    DPRINT("WriteFileEx(hFile %x)\n",hFile);
 184
 185    if (lpOverLapped == NULL)
 186         return FALSE;
 187
 188    Offset.u.LowPart = lpOverLapped->Offset;
 189    Offset.u.HighPart = lpOverLapped->OffsetHigh;
 190    lpOverLapped->Internal = STATUS_PENDING;
 191    IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
 192    ptrOffset = &Offset;
 193
 194    errCode = NtWriteFile(hFile,
 195                          NULL,
 196                          ApcRoutine,
 197                          lpCompletionRoutine,
 198                          IoStatusBlock,
 199                          (PVOID)lpBuffer,
 200                          nNumberOfBytesToWrite,
 201                          ptrOffset,
 202                          NULL);
 203    if (!NT_SUCCESS(errCode))
 204      {
 205         SetLastError(RtlNtStatusToDosError(errCode));
 206         DPRINT("WriteFileEx() failed\n");
 207         return FALSE;
 208      }
 209
 210    DPRINT("WriteFileEx() succeeded\n");
 211    return(TRUE);
 212 }
 213
 214 WINBOOL STDCALL ReadFileEx(HANDLE hFile,
 215                            LPVOID lpBuffer,
 216                            DWORD nNumberOfBytesToRead,
 217                            LPOVERLAPPED lpOverLapped,
 218                            LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 219 {
 220    LARGE_INTEGER Offset;
 221    NTSTATUS errCode;
 222    PIO_STATUS_BLOCK IoStatusBlock;
 223    PLARGE_INTEGER ptrOffset;
 224
 225    if (lpOverLapped == NULL)
 226         return FALSE;
 227
 228    Offset.u.LowPart = lpOverLapped->Offset;
 229    Offset.u.HighPart = lpOverLapped->OffsetHigh;
 230    lpOverLapped->Internal = STATUS_PENDING;
 231    IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
 232    ptrOffset = &Offset;
 233
 234    errCode = NtReadFile(hFile,
 235                         NULL,
 236                         ApcRoutine,
 237                         lpCompletionRoutine,
 238                         IoStatusBlock,
 239                         lpBuffer,
 240                         nNumberOfBytesToRead,
 241                         ptrOffset,
 242                         NULL);
 243
 244    if (!NT_SUCCESS(errCode))
 245      {
 246         SetLastError(RtlNtStatusToDosError(errCode));
 247         return(FALSE);
 248      }
 249    return(TRUE);
 250 }
 251
 252 /* EOF */