memlockbytes.c File Reference

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

Include dependency graph for memlockbytes.c:

Go to the source code of this file.

Classes
struct	HGLOBALLockBytesImpl

Macros
#define	COBJMACROS
#define	NONAMELESSUNION

Typedefs
typedef struct HGLOBALLockBytesImpl	HGLOBALLockBytesImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static HGLOBALLockBytesImpl *	impl_from_ILockBytes (ILockBytes *iface)
HRESULT WINAPI	CreateILockBytesOnHGlobal (HGLOBAL global, BOOL delete_on_release, ILockBytes **ret)
HRESULT WINAPI	GetHGlobalFromILockBytes (ILockBytes *iface, HGLOBAL *phglobal)
static HRESULT WINAPI	HGLOBALLockBytesImpl_QueryInterface (ILockBytes *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	HGLOBALLockBytesImpl_AddRef (ILockBytes *iface)
static ULONG WINAPI	HGLOBALLockBytesImpl_Release (ILockBytes *iface)
static HRESULT WINAPI	HGLOBALLockBytesImpl_ReadAt (ILockBytes *iface, ULARGE_INTEGER ulOffset, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	HGLOBALLockBytesImpl_WriteAt (ILockBytes *iface, ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	HGLOBALLockBytesImpl_Flush (ILockBytes *iface)
static HRESULT WINAPI	HGLOBALLockBytesImpl_SetSize (ILockBytes *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	HGLOBALLockBytesImpl_LockRegion (ILockBytes *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	HGLOBALLockBytesImpl_UnlockRegion (ILockBytes *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	HGLOBALLockBytesImpl_Stat (ILockBytes *iface, STATSTG *pstatstg, DWORD grfStatFlag)

Variables
static const ILockBytesVtbl	HGLOBALLockBytesImpl_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 26 of file memlockbytes.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 27 of file memlockbytes.c.

Typedef Documentation

HGLOBALLockBytesImpl

typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl

Definition at line 68 of file memlockbytes.c.

Function Documentation

CreateILockBytesOnHGlobal()

HRESULT WINAPI CreateILockBytesOnHGlobal	(	HGLOBAL	global,
		BOOL	delete_on_release,
		ILockBytes **	ret
	)

Definition at line 98 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* lockbytes;
 
  lockbytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
  if (!lockbytes) return E_OUTOFMEMORY;
 
  lockbytes->ILockBytes_iface.lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
  lockbytes->ref = 1;
 
  /*
   * Initialize the support.
   */
  lockbytes->supportHandle = global;
  lockbytes->deleteOnRelease = delete_on_release;
 
  /*
   * This method will allocate a handle if one is not supplied.
   */
  if (lockbytes->supportHandle == 0)
    lockbytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 0);
 
  /*
   * Initialize the size of the array to the size of the handle.
   */
  lockbytes->byteArraySize.u.HighPart = 0;
  lockbytes->byteArraySize.u.LowPart  = GlobalSize(lockbytes->supportHandle);
 
  *ret = &lockbytes->ILockBytes_iface;
 
  return S_OK;
}

Referenced by create_storage(), DataObjectImpl_CreateComplex(), get_data_from_storage(), get_stgmed_for_storage(), render_embed_source_hack(), stream_to_storage(), test_data_cache_save(), test_data_cache_save_data(), test_hglobal_storage_creation(), test_hglobal_storage_stat(), and test_OleCreateStaticFromData().

GetHGlobalFromILockBytes()

HRESULT WINAPI GetHGlobalFromILockBytes	(	ILockBytes *	iface,
		HGLOBAL *	phglobal
	)

Definition at line 145 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
  STATSTG stbuf;
  HRESULT hres;
  ULARGE_INTEGER start;
  ULONG xread;
 
  *phglobal = 0;
  if (This->ILockBytes_iface.lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
    *phglobal = This->supportHandle;
    if (*phglobal == 0)
      return E_INVALIDARG;
    return S_OK;
  }
  /* It is not our lockbytes implementation, so use a more generic way */
  hres = ILockBytes_Stat(iface,&stbuf,STATFLAG_NONAME);
  if (hres != S_OK) {
     ERR("Cannot ILockBytes_Stat, %x\n",hres);
     return hres;
  }
  TRACE("cbSize is %s\n", wine_dbgstr_longlong(stbuf.cbSize.QuadPart));
  *phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.u.LowPart);
  if (!*phglobal)
    return E_INVALIDARG;
  memset(&start,0,sizeof(start));
  hres = ILockBytes_ReadAt(iface, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
  GlobalUnlock(*phglobal);
  if (hres != S_OK) {
    FIXME("%p->ReadAt failed with %x\n",iface,hres);
    return hres;
  }
  if (stbuf.cbSize.u.LowPart != xread) {
    FIXME("Read size is not requested size %d vs %d?\n",stbuf.cbSize.u.LowPart, xread);
  }
  return S_OK;
}

Referenced by create_storage().

HGLOBALLockBytesImpl_AddRef()

static ULONG WINAPI HGLOBALLockBytesImpl_AddRef ( ILockBytes *  iface )

static

Definition at line 222 of file memlockbytes.c.

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

HGLOBALLockBytesImpl_Flush()

static HRESULT WINAPI HGLOBALLockBytesImpl_Flush ( ILockBytes *  iface )

static

Definition at line 396 of file memlockbytes.c.

{
  return S_OK;
}

HGLOBALLockBytesImpl_LockRegion()

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

static

Definition at line 445 of file memlockbytes.c.

{
  return STG_E_INVALIDFUNCTION;
}

HGLOBALLockBytesImpl_QueryInterface()

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

static

Definition at line 193 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 
  if (ppvObject==0)
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualIID(riid, &IID_IUnknown) ||
      IsEqualIID(riid, &IID_ILockBytes))
  {
    *ppvObject = &This->ILockBytes_iface;
  }
  else
    return E_NOINTERFACE;
 
  ILockBytes_AddRef(iface);
 
  return S_OK;
}

HGLOBALLockBytesImpl_ReadAt()

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

static

Definition at line 259 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 
  void* supportBuffer;
  ULONG bytesReadBuffer = 0;
  ULONG bytesToReadFromBuffer;
 
  /*
   * If the caller is not interested in the number of bytes read,
   * we use another buffer to avoid "if" statements in the code.
   */
  if (pcbRead == 0)
    pcbRead = &bytesReadBuffer;
 
  /*
   * Make sure the offset is valid.
   */
  if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
    return E_FAIL;
 
  /*
   * Using the known size of the array, calculate the number of bytes
   * to read.
   */
  bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
                              ulOffset.u.LowPart, cb);
 
  /*
   * Lock the buffer in position and copy the data.
   */
  supportBuffer = GlobalLock(This->supportHandle);
 
  memcpy(pv,
         (char *) supportBuffer + ulOffset.u.LowPart,
         bytesToReadFromBuffer);
 
  /*
   * Return the number of bytes read.
   */
  *pcbRead = bytesToReadFromBuffer;
 
  /*
   * Cleanup
   */
  GlobalUnlock(This->supportHandle);
 
  /*
   * The function returns S_OK if the specified number of bytes were read
   * or the end of the array was reached.
   * It returns STG_E_READFAULT if the number of bytes to read does not equal
   * the number of bytes actually read.
   */
  if(*pcbRead == cb)
    return S_OK;
 
  return STG_E_READFAULT;
}

HGLOBALLockBytesImpl_Release()

static ULONG WINAPI HGLOBALLockBytesImpl_Release ( ILockBytes *  iface )

static

Definition at line 232 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
  ULONG ref;
 
  ref = InterlockedDecrement(&This->ref);
  if (!ref)
  {
    if (This->deleteOnRelease)
    {
      GlobalFree(This->supportHandle);
      This->supportHandle = 0;
    }
    HeapFree(GetProcessHeap(), 0, This);
  }
 
  return ref;
}

HGLOBALLockBytesImpl_SetSize()

static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize ( ILockBytes *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 408 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
  HGLOBAL supportHandle;
 
  /*
   * As documented.
   */
  if (libNewSize.u.HighPart != 0)
    return STG_E_INVALIDFUNCTION;
 
  if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
    return S_OK;
 
  /*
   * Re allocate the HGlobal to fit the new size of the stream.
   */
  supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 
  if (supportHandle == 0)
    return STG_E_MEDIUMFULL;
 
  This->supportHandle = supportHandle;
  This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
 
  return S_OK;
}

HGLOBALLockBytesImpl_Stat()

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

static

Definition at line 478 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 
  memset(pstatstg, 0, sizeof(STATSTG));
 
  pstatstg->pwcsName = NULL;
  pstatstg->type     = STGTY_LOCKBYTES;
  pstatstg->cbSize   = This->byteArraySize;
 
  return S_OK;
}

HGLOBALLockBytesImpl_UnlockRegion()

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

static

Definition at line 461 of file memlockbytes.c.

{
  return STG_E_INVALIDFUNCTION;
}

HGLOBALLockBytesImpl_WriteAt()

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

static

Definition at line 331 of file memlockbytes.c.

{
  HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 
  void*          supportBuffer;
  ULARGE_INTEGER newSize;
  ULONG          bytesWritten = 0;
 
  /*
   * If the caller is not interested in the number of bytes written,
   * we use another buffer to avoid "if" statements in the code.
   */
  if (pcbWritten == 0)
    pcbWritten = &bytesWritten;
 
  if (cb == 0)
  {
    return S_OK;
  }
  else
  {
    newSize.u.HighPart = 0;
    newSize.u.LowPart = ulOffset.u.LowPart + cb;
  }
 
  /*
   * Verify if we need to grow the stream
   */
  if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
  {
    /* grow stream */
    if (ILockBytes_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
      return STG_E_MEDIUMFULL;
  }
 
  /*
   * Lock the buffer in position and copy the data.
   */
  supportBuffer = GlobalLock(This->supportHandle);
 
  memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
 
  /*
   * Return the number of bytes written.
   */
  *pcbWritten = cb;
 
  /*
   * Cleanup
   */
  GlobalUnlock(This->supportHandle);
 
  return S_OK;
}

impl_from_ILockBytes()

static HGLOBALLockBytesImpl * impl_from_ILockBytes ( ILockBytes *  iface )

inlinestatic

Definition at line 70 of file memlockbytes.c.

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

Referenced by GetHGlobalFromILockBytes(), HGLOBALLockBytesImpl_AddRef(), HGLOBALLockBytesImpl_QueryInterface(), HGLOBALLockBytesImpl_ReadAt(), HGLOBALLockBytesImpl_Release(), HGLOBALLockBytesImpl_SetSize(), HGLOBALLockBytesImpl_Stat(), and HGLOBALLockBytesImpl_WriteAt().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

HGLOBALLockBytesImpl_Vtbl

static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl

static

Initial value:

=
{
    HGLOBALLockBytesImpl_QueryInterface,
    HGLOBALLockBytesImpl_AddRef,
    HGLOBALLockBytesImpl_Release,
    HGLOBALLockBytesImpl_ReadAt,
    HGLOBALLockBytesImpl_WriteAt,
    HGLOBALLockBytesImpl_Flush,
    HGLOBALLockBytesImpl_SetSize,
    HGLOBALLockBytesImpl_LockRegion,
    HGLOBALLockBytesImpl_UnlockRegion,
    HGLOBALLockBytesImpl_Stat,
}

Definition at line 75 of file memlockbytes.c.

Referenced by CreateILockBytesOnHGlobal(), and GetHGlobalFromILockBytes().