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  *                  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 "../include/debug.h"
  21
  22 /* FUNCTIONS ****************************************************************/
  23
  24 /*
  25  * @implemented
  26  */
  27 BOOL
  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    Overlapped.hEvent = NULL;
  43         dwReserved = 0;
  44
  45         return LockFileEx(hFile, LOCKFILE_FAIL_IMMEDIATELY|LOCKFILE_EXCLUSIVE_LOCK,dwReserved,nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, &Overlapped ) ;
  46
  47 }
  48
  49
  50 /*
  51  * @implemented
  52  */
  53 BOOL
  54 STDCALL
  55 LockFileEx(
  56            HANDLE hFile,
  57            DWORD dwFlags,
  58            DWORD dwReserved,
  59            DWORD nNumberOfBytesToLockLow,
  60            DWORD nNumberOfBytesToLockHigh,
  61            LPOVERLAPPED lpOverlapped /* required! */
  62            )
  63 {
  64    LARGE_INTEGER BytesToLock;
  65    BOOL LockImmediate;
  66    BOOL LockExclusive;
  67    NTSTATUS errCode;
  68    LARGE_INTEGER Offset;
  69
  70    if(dwReserved != 0 || lpOverlapped==NULL)
  71      {
  72         SetLastError(ERROR_INVALID_PARAMETER);
  73         return FALSE;
  74      }
  75
  76    lpOverlapped->Internal = STATUS_PENDING;
  77
  78    Offset.u.LowPart = lpOverlapped->Offset;
  79    Offset.u.HighPart = lpOverlapped->OffsetHigh;
  80
  81    if ( (dwFlags & LOCKFILE_FAIL_IMMEDIATELY) == LOCKFILE_FAIL_IMMEDIATELY )
  82      LockImmediate = TRUE;
  83    else
  84      LockImmediate = FALSE;
  85
  86    if ( (dwFlags & LOCKFILE_EXCLUSIVE_LOCK) == LOCKFILE_EXCLUSIVE_LOCK )
  87      LockExclusive = TRUE;
  88    else
  89      LockExclusive = FALSE;
  90
  91    BytesToLock.u.LowPart = nNumberOfBytesToLockLow;
  92    BytesToLock.u.HighPart = nNumberOfBytesToLockHigh;
  93
  94    errCode = NtLockFile(hFile,
  95          lpOverlapped->hEvent,
  96                         NULL,
  97                         NULL,
  98                         (PIO_STATUS_BLOCK)lpOverlapped,
  99                         &Offset,
 100                         &BytesToLock,
 101                         NULL,
 102                         LockImmediate,
 103                         LockExclusive);
 104    if ( !NT_SUCCESS(errCode) )
 105      {
 106       SetLastErrorByStatus (errCode);
 107       return FALSE;
 108      }
 109
 110    return TRUE;
 111
 112 }
 113
 114
 115 /*
 116  * @implemented
 117  */
 118 BOOL
 119 STDCALL
 120 UnlockFile(
 121            HANDLE hFile,
 122            DWORD dwFileOffsetLow,
 123            DWORD dwFileOffsetHigh,
 124            DWORD nNumberOfBytesToUnlockLow,
 125            DWORD nNumberOfBytesToUnlockHigh
 126            )
 127 {
 128         OVERLAPPED Overlapped;
 129    DWORD dwReserved;
 130         Overlapped.Offset = dwFileOffsetLow;
 131         Overlapped.OffsetHigh = dwFileOffsetHigh;
 132    dwReserved = 0;
 133
 134    return UnlockFileEx(hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, &Overlapped);
 135 }
 136
 137
 138 /*
 139  * @implemented
 140  */
 141 BOOL
 142 STDCALL
 143 UnlockFileEx(
 144         HANDLE hFile,
 145         DWORD dwReserved,
 146         DWORD nNumberOfBytesToUnLockLow,
 147         DWORD nNumberOfBytesToUnLockHigh,
 148         LPOVERLAPPED lpOverlapped /* required! */
 149         )
 150 {
 151    LARGE_INTEGER BytesToUnLock;
 152    LARGE_INTEGER StartAddress;
 153    NTSTATUS errCode;
 154
 155    if(dwReserved != 0 || lpOverlapped == NULL)
 156      {
 157         SetLastError(ERROR_INVALID_PARAMETER);
 158         return FALSE;
 159      }
 160
 161    BytesToUnLock.u.LowPart = nNumberOfBytesToUnLockLow;
 162    BytesToUnLock.u.HighPart = nNumberOfBytesToUnLockHigh;
 163
 164    StartAddress.u.LowPart = lpOverlapped->Offset;
 165    StartAddress.u.HighPart = lpOverlapped->OffsetHigh;
 166
 167    errCode = NtUnlockFile(hFile,
 168                           (PIO_STATUS_BLOCK)lpOverlapped,
 169                           &StartAddress,
 170                           &BytesToUnLock,
 171                           NULL);
 172    if ( !NT_SUCCESS(errCode) ) {
 173       SetLastErrorByStatus (errCode);
 174       return FALSE;
 175    }
 176
 177    return TRUE;
 178 }
 179
 180 /* EOF */