reactos/lib/kernel32/file/lock.c

   1 /* $Id: lock.c,v 1.7 2002/09/08 10:22:42 chorns Exp $
   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 <ddk/ntddk.h>
  18 #include <windows.h>
  19 #include <wchar.h>
  20 #include <string.h>
  21
  22 //#define NDEBUG
  23 #include <kernel32/kernel32.h>
  24 #include <kernel32/error.h>
  25
  26 /* FUNCTIONS ****************************************************************/
  27
  28 WINBOOL
  29 STDCALL
  30 LockFile(
  31          HANDLE hFile,
  32          DWORD dwFileOffsetLow,
  33          DWORD dwFileOffsetHigh,
  34          DWORD nNumberOfBytesToLockLow,
  35          DWORD nNumberOfBytesToLockHigh
  36          )
  37 {
  38         DWORD dwReserved;
  39         OVERLAPPED Overlapped;
  40
  41         Overlapped.Offset = dwFileOffsetLow;
  42         Overlapped.OffsetHigh = dwFileOffsetHigh;
  43         dwReserved = 0;
  44
  45         return LockFileEx(hFile, LOCKFILE_FAIL_IMMEDIATELY|LOCKFILE_EXCLUSIVE_LOCK,dwReserved,nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, &Overlapped ) ;
  46
  47 }
  48
  49 WINBOOL
  50 STDCALL
  51 LockFileEx(
  52            HANDLE hFile,
  53            DWORD dwFlags,
  54            DWORD dwReserved,
  55            DWORD nNumberOfBytesToLockLow,
  56            DWORD nNumberOfBytesToLockHigh,
  57            LPOVERLAPPED lpOverlapped
  58            )
  59 {
  60    LARGE_INTEGER BytesToLock;
  61    BOOL LockImmediate;
  62    BOOL LockExclusive;
  63    NTSTATUS errCode;
  64    LARGE_INTEGER Offset;
  65
  66    if(dwReserved != 0)
  67      {
  68         SetLastError(ERROR_INVALID_PARAMETER);
  69         return FALSE;
  70      }
  71
  72    lpOverlapped->Internal = STATUS_PENDING;
  73
  74    Offset.u.LowPart = lpOverlapped->Offset;
  75    Offset.u.HighPart = lpOverlapped->OffsetHigh;
  76
  77    if ( (dwFlags & LOCKFILE_FAIL_IMMEDIATELY) == LOCKFILE_FAIL_IMMEDIATELY )
  78      LockImmediate = TRUE;
  79    else
  80      LockImmediate = FALSE;
  81
  82    if ( (dwFlags & LOCKFILE_EXCLUSIVE_LOCK) == LOCKFILE_EXCLUSIVE_LOCK )
  83      LockExclusive = TRUE;
  84    else
  85      LockExclusive = FALSE;
  86
  87    BytesToLock.u.LowPart = nNumberOfBytesToLockLow;
  88    BytesToLock.u.HighPart = nNumberOfBytesToLockHigh;
  89
  90    errCode = NtLockFile(hFile,
  91                         NULL,
  92                         NULL,
  93                         NULL,
  94                         (PIO_STATUS_BLOCK)lpOverlapped,
  95                         &Offset,
  96                         &BytesToLock,
  97                         NULL,
  98                         LockImmediate,
  99                         LockExclusive);
 100    if ( !NT_SUCCESS(errCode) )
 101      {
 102       SetLastErrorByStatus (errCode);
 103       return FALSE;
 104      }
 105
 106    return TRUE;
 107
 108 }
 109
 110 WINBOOL
 111 STDCALL
 112 UnlockFile(
 113            HANDLE hFile,
 114            DWORD dwFileOffsetLow,
 115            DWORD dwFileOffsetHigh,
 116            DWORD nNumberOfBytesToUnlockLow,
 117            DWORD nNumberOfBytesToUnlockHigh
 118            )
 119 {
 120         DWORD dwReserved;
 121         OVERLAPPED Overlapped;
 122         Overlapped.Offset = dwFileOffsetLow;
 123         Overlapped.OffsetHigh = dwFileOffsetHigh;
 124         dwReserved = 0;
 125         return UnlockFileEx(hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh, &Overlapped);
 126
 127 }
 128
 129
 130
 131 WINBOOL
 132 STDCALL
 133 UnlockFileEx(
 134         HANDLE hFile,
 135         DWORD dwReserved,
 136         DWORD nNumberOfBytesToUnLockLow,
 137         DWORD nNumberOfBytesToUnLockHigh,
 138         LPOVERLAPPED lpOverlapped
 139         )
 140 {
 141    LARGE_INTEGER BytesToUnLock;
 142    LARGE_INTEGER StartAddress;
 143    NTSTATUS errCode;
 144
 145    if(dwReserved != 0)
 146      {
 147         SetLastError(ERROR_INVALID_PARAMETER);
 148         return FALSE;
 149      }
 150    if ( lpOverlapped == NULL )
 151      {
 152         SetLastError(ERROR_INVALID_PARAMETER);
 153         return FALSE;
 154      }
 155
 156    BytesToUnLock.u.LowPart = nNumberOfBytesToUnLockLow;
 157    BytesToUnLock.u.HighPart = nNumberOfBytesToUnLockHigh;
 158
 159    StartAddress.u.LowPart = lpOverlapped->Offset;
 160    StartAddress.u.HighPart = lpOverlapped->OffsetHigh;
 161
 162    errCode = NtUnlockFile(hFile,
 163                           (PIO_STATUS_BLOCK)lpOverlapped,
 164                           &StartAddress,
 165                           &BytesToUnLock,
 166                           NULL);
 167    if ( !NT_SUCCESS(errCode) ) {
 168       SetLastErrorByStatus (errCode);
 169       return FALSE;
 170    }
 171
 172    return TRUE;
 173 }
 174
 175 /* EOF */