lib/kernel32/file/lock.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/file/file.c
   6  * PURPOSE:         Directory functions
   7  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   8  *                  GetTempFileName is modified from WINE [ Alexandre Juiliard ]
   9  * UPDATE HISTORY:
  10  *                  Created 01/11/98
  11  */
  12
  13 /* FIXME: the large integer manipulations in this file dont handle overflow  */
  14
  15 /* INCLUDES ****************************************************************/
  16
  17 #include <k32.h>
  18
  19 #define NDEBUG
  20 #include <kernel32/kernel32.h>
  21
  22 /* FUNCTIONS ****************************************************************/
  23
  24 /*
  25  * @implemented
  26  */
  27 WINBOOL
  28 STDCALL
  29 LockFile(
  30          HANDLE hFile,
  31          DWORD dwFileOffsetLow,
  32          DWORD dwFileOffsetHigh,
  33          DWORD nNumberOfBytesToLockLow,
  34          DWORD nNumberOfBytesToLockHigh
  35          )
  36 {
  37         DWORD dwReserved;
  38         OVERLAPPED Overlapped;
  39
  40         Overlapped.Offset = dwFileOffsetLow;
  41         Overlapped.OffsetHigh = dwFileOffsetHigh;
  42         dwReserved = 0;
  43
  44         return LockFileEx(hFile, LOCKFILE_FAIL_IMMEDIATELY|LOCKFILE_EXCLUSIVE_LOCK,dwReserved,nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, &Overlapped ) ;
  45
  46 }
  47
  48
  49 /*
  50  * @implemented
  51  */
  52 WINBOOL
  53 STDCALL
  54 LockFileEx(
  55            HANDLE hFile,
  56            DWORD dwFlags,
  57            DWORD dwReserved,
  58            DWORD nNumberOfBytesToLockLow,
  59            DWORD nNumberOfBytesToLockHigh,
  60            LPOVERLAPPED lpOverlapped
  61            )
  62 {
  63    LARGE_INTEGER BytesToLock;
  64    BOOL LockImmediate;
  65    BOOL LockExclusive;
  66    NTSTATUS errCode;
  67    LARGE_INTEGER Offset;
  68
  69    if(dwReserved != 0)
  70      {
  71         SetLastError(ERROR_INVALID_PARAMETER);
  72         return FALSE;
  73      }
  74
  75    lpOverlapped->Internal = STATUS_PENDING;
  76
  77    Offset.u.LowPart = lpOverlapped->Offset;
  78    Offset.u.HighPart = lpOverlapped->OffsetHigh;
  79
  80    if ( (dwFlags & LOCKFILE_FAIL_IMMEDIATELY) == LOCKFILE_FAIL_IMMEDIATELY )
  81      LockImmediate = TRUE;
  82    else
  83      LockImmediate = FALSE;
  84
  85    if ( (dwFlags & LOCKFILE_EXCLUSIVE_LOCK) == LOCKFILE_EXCLUSIVE_LOCK )
  86      LockExclusive = TRUE;
  87    else
  88      LockExclusive = FALSE;
  89
  90    BytesToLock.u.LowPart = nNumberOfBytesToLockLow;
  91    BytesToLock.u.HighPart = nNumberOfBytesToLockHigh;
  92
  93    errCode = NtLockFile(hFile,
  94                         NULL,
  95                         NULL,
  96                         NULL,
  97                         (PIO_STATUS_BLOCK)lpOverlapped,
  98                         &Offset,
  99                         &BytesToLock,
 100                         NULL,
 101                         LockImmediate,
 102                         LockExclusive);
 103    if ( !NT_SUCCESS(errCode) )
 104      {
 105       SetLastErrorByStatus (errCode);
 106       return FALSE;
 107      }
 108
 109    return TRUE;
 110
 111 }
 112
 113
 114 /*
 115  * @implemented
 116  */
 117 WINBOOL
 118 STDCALL
 119 UnlockFile(
 120            HANDLE hFile,
 121            DWORD dwFileOffsetLow,
 122            DWORD dwFileOffsetHigh,
 123            DWORD nNumberOfBytesToUnlockLow,
 124            DWORD nNumberOfBytesToUnlockHigh
 125            )
 126 {
 127         DWORD dwReserved;
 128         OVERLAPPED Overlapped;
 129         Overlapped.Offset = dwFileOffsetLow;
 130         Overlapped.OffsetHigh = dwFileOffsetHigh;
 131         dwReserved = 0;
 132         return UnlockFileEx(hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, &Overlapped);
 133
 134 }
 135
 136
 137 /*
 138  * @implemented
 139  */
 140 WINBOOL
 141 STDCALL
 142 UnlockFileEx(
 143         HANDLE hFile,
 144         DWORD dwReserved,
 145         DWORD nNumberOfBytesToUnLockLow,
 146         DWORD nNumberOfBytesToUnLockHigh,
 147         LPOVERLAPPED lpOverlapped
 148         )
 149 {
 150    LARGE_INTEGER BytesToUnLock;
 151    LARGE_INTEGER StartAddress;
 152    NTSTATUS errCode;
 153
 154    if(dwReserved != 0)
 155      {
 156         SetLastError(ERROR_INVALID_PARAMETER);
 157         return FALSE;
 158      }
 159    if ( lpOverlapped == NULL )
 160      {
 161         SetLastError(ERROR_INVALID_PARAMETER);
 162         return FALSE;
 163      }
 164
 165    BytesToUnLock.u.LowPart = nNumberOfBytesToUnLockLow;
 166    BytesToUnLock.u.HighPart = nNumberOfBytesToUnLockHigh;
 167
 168    StartAddress.u.LowPart = lpOverlapped->Offset;
 169    StartAddress.u.HighPart = lpOverlapped->OffsetHigh;
 170
 171    errCode = NtUnlockFile(hFile,
 172                           (PIO_STATUS_BLOCK)lpOverlapped,
 173                           &StartAddress,
 174                           &BytesToUnLock,
 175                           NULL);
 176    if ( !NT_SUCCESS(errCode) ) {
 177       SetLastErrorByStatus (errCode);
 178       return FALSE;
 179    }
 180
 181    return TRUE;
 182 }
 183
 184 /* EOF */