filelockbytes.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "objbase.h"
#include "ole2.h"
#include "storage32.h"
#include "wine/debug.h"

Include dependency graph for filelockbytes.c:

Go to the source code of this file.

Classes
struct	FileLockBytesImpl

Macros
#define	COBJMACROS

Typedefs
typedef struct FileLockBytesImpl	FileLockBytesImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (storage)
static FileLockBytesImpl *	impl_from_ILockBytes (ILockBytes *iface)
static DWORD	GetProtectMode (DWORD openFlags)
HRESULT	FileLockBytesImpl_Construct (HANDLE hFile, DWORD openFlags, LPCWSTR pwcsName, ILockBytes **pLockBytes)
static HRESULT WINAPI	FileLockBytesImpl_QueryInterface (ILockBytes *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	FileLockBytesImpl_AddRef (ILockBytes *iface)
static ULONG WINAPI	FileLockBytesImpl_Release (ILockBytes *iface)
static HRESULT WINAPI	FileLockBytesImpl_ReadAt (ILockBytes *iface, ULARGE_INTEGER ulOffset, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	FileLockBytesImpl_WriteAt (ILockBytes *iface, ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	FileLockBytesImpl_Flush (ILockBytes *iface)
static HRESULT WINAPI	FileLockBytesImpl_SetSize (ILockBytes *iface, ULARGE_INTEGER newSize)
static HRESULT	get_lock_error (void)
static HRESULT WINAPI	FileLockBytesImpl_LockRegion (ILockBytes *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	FileLockBytesImpl_UnlockRegion (ILockBytes *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	FileLockBytesImpl_Stat (ILockBytes *iface, STATSTG *pstatstg, DWORD grfStatFlag)

Variables
static const ILockBytesVtbl	FileLockBytesImpl_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 30 of file filelockbytes.c.

Typedef Documentation

FileLockBytesImpl

typedef struct FileLockBytesImpl FileLockBytesImpl

Function Documentation

FileLockBytesImpl_AddRef()

static ULONG WINAPI FileLockBytesImpl_AddRef ( ILockBytes *  iface )

static

Definition at line 144 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    return InterlockedIncrement(&This->ref);
}

FileLockBytesImpl_Construct()

HRESULT FileLockBytesImpl_Construct	(	HANDLE	hFile,
		DWORD	openFlags,
		LPCWSTR	pwcsName,
		ILockBytes **	pLockBytes
	)

Definition at line 86 of file filelockbytes.c.

{
  FileLockBytesImpl *This;
  WCHAR fullpath[MAX_PATH];
 
  if (hFile == INVALID_HANDLE_VALUE)
    return E_FAIL;
 
  This = HeapAlloc(GetProcessHeap(), 0, sizeof(FileLockBytesImpl));
 
  if (!This)
    return E_OUTOFMEMORY;
 
  This->ILockBytes_iface.lpVtbl = &FileLockBytesImpl_Vtbl;
  This->ref = 1;
  This->hfile = hFile;
  This->flProtect = GetProtectMode(openFlags);
 
  if(pwcsName) {
    if (!GetFullPathNameW(pwcsName, MAX_PATH, fullpath, NULL))
    {
      lstrcpynW(fullpath, pwcsName, MAX_PATH);
    }
    This->pwcsName = HeapAlloc(GetProcessHeap(), 0,
                              (lstrlenW(fullpath)+1)*sizeof(WCHAR));
    if (!This->pwcsName)
    {
       HeapFree(GetProcessHeap(), 0, This);
       return E_OUTOFMEMORY;
    }
    lstrcpyW(This->pwcsName, fullpath);
  }
  else
    This->pwcsName = NULL;
 
  *pLockBytes = &This->ILockBytes_iface;
 
  return S_OK;
}

Referenced by StorageImpl_Construct().

FileLockBytesImpl_Flush()

static HRESULT WINAPI FileLockBytesImpl_Flush ( ILockBytes *  iface )

static

Definition at line 280 of file filelockbytes.c.

{
    return S_OK;
}

FileLockBytesImpl_LockRegion()

static HRESULT WINAPI FileLockBytesImpl_LockRegion ( ILockBytes *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 321 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    OVERLAPPED ol;
    DWORD lock_flags = LOCKFILE_FAIL_IMMEDIATELY;
 
    TRACE("ofs %lu count %lu flags %lx\n", libOffset.LowPart, cb.LowPart, dwLockType);
 
    if (dwLockType & LOCK_WRITE)
        return STG_E_INVALIDFUNCTION;
 
    if (dwLockType & (LOCK_EXCLUSIVE|LOCK_ONLYONCE))
        lock_flags |= LOCKFILE_EXCLUSIVE_LOCK;
 
    ol.hEvent = 0;
    ol.Offset = libOffset.LowPart;
    ol.OffsetHigh = libOffset.HighPart;
 
    if (LockFileEx(This->hfile, lock_flags, 0, cb.LowPart, cb.HighPart, &ol))
        return S_OK;
    return get_lock_error();
}

FileLockBytesImpl_QueryInterface()

static HRESULT WINAPI FileLockBytesImpl_QueryInterface ( ILockBytes *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 128 of file filelockbytes.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ILockBytes))
        *ppvObject = iface;
    else
    {
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppvObject);
 
    return S_OK;
}

FileLockBytesImpl_ReadAt()

static HRESULT WINAPI FileLockBytesImpl_ReadAt ( ILockBytes *  iface, ULARGE_INTEGER  ulOffset, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 175 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    ULONG bytes_left = cb;
    LPBYTE readPtr = pv;
    BOOL ret;
    LARGE_INTEGER offset;
    ULONG cbRead;
 
    TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.LowPart, pv, cb, pcbRead);
 
    /* verify a sane environment */
    if (!This) return E_FAIL;
 
    if (pcbRead)
        *pcbRead = 0;
 
    offset.QuadPart = ulOffset.QuadPart;
 
    ret = SetFilePointerEx(This->hfile, offset, NULL, FILE_BEGIN);
 
    if (!ret)
        return STG_E_READFAULT;
 
    while (bytes_left)
    {
        ret = ReadFile(This->hfile, readPtr, bytes_left, &cbRead, NULL);
 
        if (!ret || cbRead == 0)
            return STG_E_READFAULT;
 
        if (pcbRead)
            *pcbRead += cbRead;
 
        bytes_left -= cbRead;
        readPtr += cbRead;
    }
 
    TRACE("finished\n");
    return S_OK;
}

FileLockBytesImpl_Release()

static ULONG WINAPI FileLockBytesImpl_Release ( ILockBytes *  iface )

static

Definition at line 150 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    ULONG ref;
 
    ref = InterlockedDecrement(&This->ref);
 
    if (ref == 0)
    {
        CloseHandle(This->hfile);
        HeapFree(GetProcessHeap(), 0, This->pwcsName);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

FileLockBytesImpl_SetSize()

static HRESULT WINAPI FileLockBytesImpl_SetSize ( ILockBytes *  iface, ULARGE_INTEGER  newSize  )

static

Definition at line 291 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    HRESULT hr = S_OK;
    LARGE_INTEGER newpos;
 
    TRACE("new size %lu\n", newSize.LowPart);
 
    newpos.QuadPart = newSize.QuadPart;
    if (SetFilePointerEx(This->hfile, newpos, NULL, FILE_BEGIN))
    {
        SetEndOfFile(This->hfile);
    }
 
    return hr;
}

FileLockBytesImpl_Stat()

static HRESULT WINAPI FileLockBytesImpl_Stat ( ILockBytes *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 365 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
 
    if (!(STATFLAG_NONAME & grfStatFlag) && This->pwcsName)
    {
        pstatstg->pwcsName =
          CoTaskMemAlloc((lstrlenW(This->pwcsName)+1)*sizeof(WCHAR));
 
        lstrcpyW(pstatstg->pwcsName, This->pwcsName);
    }
    else
        pstatstg->pwcsName = NULL;
 
    pstatstg->type = STGTY_LOCKBYTES;
 
    pstatstg->cbSize.LowPart = GetFileSize(This->hfile, &pstatstg->cbSize.HighPart);
    /* FIXME: If the implementation is exported, we'll need to set other fields. */
 
    pstatstg->grfLocksSupported = LOCK_EXCLUSIVE|LOCK_ONLYONCE|WINE_LOCK_READ;
 
    return S_OK;
}

FileLockBytesImpl_UnlockRegion()

static HRESULT WINAPI FileLockBytesImpl_UnlockRegion ( ILockBytes *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 345 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    OVERLAPPED ol;
 
    TRACE("ofs %lu count %lu flags %lx\n", libOffset.LowPart, cb.LowPart, dwLockType);
 
    if (dwLockType & LOCK_WRITE)
        return STG_E_INVALIDFUNCTION;
 
    ol.hEvent = 0;
    ol.Offset = libOffset.LowPart;
    ol.OffsetHigh = libOffset.HighPart;
 
    if (UnlockFileEx(This->hfile, 0, cb.LowPart, cb.HighPart, &ol))
        return S_OK;
    return get_lock_error();
}

FileLockBytesImpl_WriteAt()

static HRESULT WINAPI FileLockBytesImpl_WriteAt ( ILockBytes *  iface, ULARGE_INTEGER  ulOffset, const void *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 230 of file filelockbytes.c.

{
    FileLockBytesImpl* This = impl_from_ILockBytes(iface);
    ULONG bytes_left = cb;
    const BYTE *writePtr = pv;
    BOOL ret;
    LARGE_INTEGER offset;
    ULONG cbWritten;
 
    TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.LowPart, pv, cb, pcbWritten);
 
    /* verify a sane environment */
    if (!This) return E_FAIL;
 
    if (This->flProtect != PAGE_READWRITE)
        return STG_E_ACCESSDENIED;
 
    if (pcbWritten)
        *pcbWritten = 0;
 
    offset.QuadPart = ulOffset.QuadPart;
 
    ret = SetFilePointerEx(This->hfile, offset, NULL, FILE_BEGIN);
 
    if (!ret)
        return STG_E_WRITEFAULT;
 
    while (bytes_left)
    {
        ret = WriteFile(This->hfile, writePtr, bytes_left, &cbWritten, NULL);
 
        if (!ret)
            return STG_E_WRITEFAULT;
 
        if (pcbWritten)
            *pcbWritten += cbWritten;
 
        bytes_left -= cbWritten;
        writePtr += cbWritten;
    }
 
    TRACE("finished\n");
    return S_OK;
}

get_lock_error()

static HRESULT get_lock_error ( void  )

static

Definition at line 308 of file filelockbytes.c.

{
    switch (GetLastError())
    {
    case ERROR_LOCK_VIOLATION: return STG_E_LOCKVIOLATION; break;
    case ERROR_ACCESS_DENIED:  return STG_E_ACCESSDENIED; break;
    case ERROR_NOT_SUPPORTED:  return STG_E_INVALIDFUNCTION; break;
    default:
        FIXME("no mapping for error %ld\n", GetLastError());
        return STG_E_INVALIDFUNCTION;
    }
}

Referenced by FileLockBytesImpl_LockRegion(), and FileLockBytesImpl_UnlockRegion().

GetProtectMode()

static DWORD GetProtectMode ( DWORD  openFlags )

static

Definition at line 70 of file filelockbytes.c.

{
    switch(STGM_ACCESS_MODE(openFlags))
    {
    case STGM_WRITE:
    case STGM_READWRITE:
        return PAGE_READWRITE;
    }
    return PAGE_READONLY;
}

Referenced by FileLockBytesImpl_Construct().

impl_from_ILockBytes()

static FileLockBytesImpl * impl_from_ILockBytes ( ILockBytes *  iface )

inlinestatic

Definition at line 55 of file filelockbytes.c.

{
    return CONTAINING_RECORD(iface, FileLockBytesImpl, ILockBytes_iface);
}

Referenced by FileLockBytesImpl_AddRef(), FileLockBytesImpl_LockRegion(), FileLockBytesImpl_ReadAt(), FileLockBytesImpl_Release(), FileLockBytesImpl_SetSize(), FileLockBytesImpl_Stat(), FileLockBytesImpl_UnlockRegion(), and FileLockBytesImpl_WriteAt().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

storage

)

Variable Documentation

FileLockBytesImpl_Vtbl

static const ILockBytesVtbl FileLockBytesImpl_Vtbl

static

Initial value:

= {
    FileLockBytesImpl_QueryInterface,
    FileLockBytesImpl_AddRef,
    FileLockBytesImpl_Release,
    FileLockBytesImpl_ReadAt,
    FileLockBytesImpl_WriteAt,
    FileLockBytesImpl_Flush,
    FileLockBytesImpl_SetSize,
    FileLockBytesImpl_LockRegion,
    FileLockBytesImpl_UnlockRegion,
    FileLockBytesImpl_Stat
}

Definition at line 53 of file filelockbytes.c.

Referenced by FileLockBytesImpl_Construct().