reactos/lib/kernel32/file/rw.c

   1 /* $Id: rw.c,v 1.12 2000/05/13 13:50:56 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 STDCALL WriteFileEx (HANDLE                             hFile,
 168                              LPCVOID                            lpBuffer,
 169                              DWORD                              nNumberOfBytesToWrite,
 170                              LPOVERLAPPED                       lpOverLapped,
 171                              LPOVERLAPPED_COMPLETION_ROUTINE    lpCompletionRoutine
 172                              )
 173 {
 174
 175    LARGE_INTEGER Offset;
 176    NTSTATUS errCode;
 177    PIO_STATUS_BLOCK IoStatusBlock;
 178    PLARGE_INTEGER ptrOffset;
 179
 180    DPRINT("WriteFileEx(hFile %x)\n",hFile);
 181
 182    if (lpOverLapped == NULL)
 183         return FALSE;
 184
 185    Offset.u.LowPart = lpOverLapped->Offset;
 186    Offset.u.HighPart = lpOverLapped->OffsetHigh;
 187    lpOverLapped->Internal = STATUS_PENDING;
 188    IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
 189    ptrOffset = &Offset;
 190
 191    errCode = NtWriteFile(hFile,
 192                          NULL,
 193                          ApcRoutine,
 194                          lpCompletionRoutine,
 195                          IoStatusBlock,
 196                          (PVOID)lpBuffer,
 197                          nNumberOfBytesToWrite,
 198                          ptrOffset,
 199                          NULL);
 200    if (!NT_SUCCESS(errCode))
 201      {
 202         SetLastError(RtlNtStatusToDosError(errCode));
 203         DPRINT("WriteFileEx() failed\n");
 204         return FALSE;
 205      }
 206
 207    DPRINT("WriteFileEx() succeeded\n");
 208    return(TRUE);
 209 }
 210
 211 WINBOOL STDCALL ReadFileEx(HANDLE hFile,
 212                            LPVOID lpBuffer,
 213                            DWORD nNumberOfBytesToRead,
 214                            LPOVERLAPPED lpOverLapped,
 215                            LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 216 {
 217    LARGE_INTEGER Offset;
 218    NTSTATUS errCode;
 219    PIO_STATUS_BLOCK IoStatusBlock;
 220    PLARGE_INTEGER ptrOffset;
 221
 222    if (lpOverLapped == NULL)
 223         return FALSE;
 224
 225    Offset.u.LowPart = lpOverLapped->Offset;
 226    Offset.u.HighPart = lpOverLapped->OffsetHigh;
 227    lpOverLapped->Internal = STATUS_PENDING;
 228    IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
 229    ptrOffset = &Offset;
 230
 231    errCode = NtReadFile(hFile,
 232                         NULL,
 233                         ApcRoutine,
 234                         lpCompletionRoutine,
 235                         IoStatusBlock,
 236                         lpBuffer,
 237                         nNumberOfBytesToRead,
 238                         ptrOffset,
 239                         NULL);
 240
 241    if (!NT_SUCCESS(errCode))
 242      {
 243         SetLastError(RtlNtStatusToDosError(errCode));
 244         return(FALSE);
 245      }
 246    return(TRUE);
 247 }
 248
 249 /* EOF */