reactos/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  * UPDATE HISTORY:
   9  *                  Created 01/11/98
  10  */
  11
  12 /* FIXME: the large integer manipulations in this file dont handle overflow  */
  13
  14 /* INCLUDES ****************************************************************/
  15
  16 #include <k32.h>
  17
  18 #define NDEBUG
  19 #include "../include/debug.h"
  20
  21 /* FUNCTIONS ****************************************************************/
  22
  23 /*
  24  * @implemented
  25  */
  26 BOOL
  27 STDCALL
  28 LockFile(
  29          HANDLE hFile,
  30          DWORD dwFileOffsetLow,
  31          DWORD dwFileOffsetHigh,
  32          DWORD nNumberOfBytesToLockLow,
  33          DWORD nNumberOfBytesToLockHigh
  34          )
  35 {
  36         DWORD dwReserved;
  37         OVERLAPPED Overlapped;
  38
  39         Overlapped.Offset = dwFileOffsetLow;
  40         Overlapped.OffsetHigh = dwFileOffsetHigh;
  41    Overlapped.hEvent = NULL;
  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 BOOL
  53 STDCALL
  54 LockFileEx(
  55            HANDLE hFile,
  56            DWORD dwFlags,
  57            DWORD dwReserved,
  58            DWORD nNumberOfBytesToLockLow,
  59            DWORD nNumberOfBytesToLockHigh,
  60            LPOVERLAPPED lpOverlapped /* required! */
  61            )
  62 {
  63    LARGE_INTEGER BytesToLock;
  64    BOOL LockImmediate;
  65    BOOL LockExclusive;
  66    NTSTATUS errCode;
  67    LARGE_INTEGER Offset;
  68
  69    if(dwReserved != 0 || lpOverlapped==NULL)
  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          lpOverlapped->hEvent,
  95                         NULL,
  96                         NULL,
  97                         (PIO_STATUS_BLOCK)lpOverlapped,
  98                         &Offset,
  99                         &BytesToLock,
 100                         0,
 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 BOOL
 118 STDCALL
 119 UnlockFile(
 120            HANDLE hFile,
 121            DWORD dwFileOffsetLow,
 122            DWORD dwFileOffsetHigh,
 123            DWORD nNumberOfBytesToUnlockLow,
 124            DWORD nNumberOfBytesToUnlockHigh
 125            )
 126 {
 127         OVERLAPPED Overlapped;
 128    DWORD dwReserved;
 129         Overlapped.Offset = dwFileOffsetLow;
 130         Overlapped.OffsetHigh = dwFileOffsetHigh;
 131    dwReserved = 0;
 132
 133    return UnlockFileEx(hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, &Overlapped);
 134 }
 135
 136
 137 /*
 138  * @implemented
 139  */
 140 BOOL
 141 STDCALL
 142 UnlockFileEx(
 143         HANDLE hFile,
 144         DWORD dwReserved,
 145         DWORD nNumberOfBytesToUnLockLow,
 146         DWORD nNumberOfBytesToUnLockHigh,
 147         LPOVERLAPPED lpOverlapped /* required! */
 148         )
 149 {
 150    LARGE_INTEGER BytesToUnLock;
 151    LARGE_INTEGER StartAddress;
 152    NTSTATUS errCode;
 153
 154    if(dwReserved != 0 || lpOverlapped == NULL)
 155      {
 156         SetLastError(ERROR_INVALID_PARAMETER);
 157         return FALSE;
 158      }
 159
 160    BytesToUnLock.u.LowPart = nNumberOfBytesToUnLockLow;
 161    BytesToUnLock.u.HighPart = nNumberOfBytesToUnLockHigh;
 162
 163    StartAddress.u.LowPart = lpOverlapped->Offset;
 164    StartAddress.u.HighPart = lpOverlapped->OffsetHigh;
 165
 166    errCode = NtUnlockFile(hFile,
 167                           (PIO_STATUS_BLOCK)lpOverlapped,
 168                           &StartAddress,
 169                           &BytesToUnLock,
 170                           0);
 171    if ( !NT_SUCCESS(errCode) ) {
 172       SetLastErrorByStatus (errCode);
 173       return FALSE;
 174    }
 175
 176    return TRUE;
 177 }
 178
 179 /* EOF */