stg_prop.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winuser.h"
#include "wine/asm.h"
#include "wine/debug.h"
#include "dictionary.h"
#include "storage32.h"
#include "enumx.h"
#include "oleauto.h"

Include dependency graph for stg_prop.c:

Go to the source code of this file.

Classes
struct	tagPROPERTYSETHEADER
struct	tagFORMATIDOFFSET
struct	tagPROPERTYSECTIONHEADER
struct	tagPROPERTYIDOFFSET
struct	tagPropertyStorage_impl
struct	DictionaryClosure
struct	PropertyClosure

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	PROPSETHDR_BYTEORDER_MAGIC   0xfffe
#define	PROPSETHDR_OSVER_KIND_WIN16   0
#define	PROPSETHDR_OSVER_KIND_MAC   1
#define	PROPSETHDR_OSVER_KIND_WIN32   2
#define	CP_UNICODE   1200
#define	MAX_VERSION_0_PROP_NAME_LENGTH   256
#define	CFTAG_WINDOWS   (-1L)
#define	CFTAG_MACINTOSH   (-2L)
#define	CFTAG_FMTID   (-3L)
#define	CFTAG_NODATA   0L
#define	PropertyStorage_ByteSwapString(s, l)
#define	__thiscall_wrapper   __cdecl
#define	SECTIONHEADER_OFFSET   sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET)
#define	BITS_PER_BYTE   8
#define	CHARMASK   0x1f
#define	BITS_IN_CHARMASK   5
#define	NUM_ALPHA_CHARS   26

Typedefs
typedef struct tagPROPERTYSETHEADER	PROPERTYSETHEADER
typedef struct tagFORMATIDOFFSET	FORMATIDOFFSET
typedef struct tagPROPERTYSECTIONHEADER	PROPERTYSECTIONHEADER
typedef struct tagPROPERTYIDOFFSET	PROPERTYIDOFFSET
typedef struct tagPropertyStorage_impl	PropertyStorage_impl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (storage)
static StorageImpl *	impl_from_IPropertySetStorage (IPropertySetStorage *iface)
static HRESULT	PropertyStorage_ReadFromStream (PropertyStorage_impl *)
static HRESULT	PropertyStorage_WriteToStream (PropertyStorage_impl *)
static HRESULT	PropertyStorage_CreateDictionaries (PropertyStorage_impl *)
static void	PropertyStorage_DestroyDictionaries (PropertyStorage_impl *)
static HRESULT	PropertyStorage_PropVariantCopy (PROPVARIANT *prop, const PROPVARIANT *propvar, LCID targetCP, LCID srcCP)
static HRESULT	PropertyStorage_StringCopy (LPCSTR src, LCID srcCP, LPSTR *dst, LCID targetCP)
static HRESULT	create_EnumSTATPROPSETSTG (StorageImpl *, IEnumSTATPROPSETSTG **)
static HRESULT	create_EnumSTATPROPSTG (PropertyStorage_impl *, IEnumSTATPROPSTG **)
static PropertyStorage_impl *	impl_from_IPropertyStorage (IPropertyStorage *iface)
static HRESULT WINAPI	IPropertyStorage_fnQueryInterface (IPropertyStorage *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	IPropertyStorage_fnAddRef (IPropertyStorage *iface)
static ULONG WINAPI	IPropertyStorage_fnRelease (IPropertyStorage *iface)
static PROPVARIANT *	PropertyStorage_FindProperty (PropertyStorage_impl *This, DWORD propid)
static PROPVARIANT *	PropertyStorage_FindPropertyByName (PropertyStorage_impl *This, LPCWSTR name)
static LPWSTR	PropertyStorage_FindPropertyNameById (PropertyStorage_impl *This, DWORD propid)
static HRESULT WINAPI	IPropertyStorage_fnReadMultiple (IPropertyStorage *iface, ULONG cpspec, const PROPSPEC rgpspec[], PROPVARIANT rgpropvar[])
static HRESULT	PropertyStorage_StorePropWithId (PropertyStorage_impl *This, PROPID propid, const PROPVARIANT *propvar, LCID lcid)
static HRESULT	PropertyStorage_StoreNameWithId (PropertyStorage_impl *This, LPCSTR srcName, LCID cp, PROPID id)
static HRESULT WINAPI	IPropertyStorage_fnWriteMultiple (IPropertyStorage *iface, ULONG cpspec, const PROPSPEC rgpspec[], const PROPVARIANT rgpropvar[], PROPID propidNameFirst)
static HRESULT WINAPI	IPropertyStorage_fnDeleteMultiple (IPropertyStorage *iface, ULONG cpspec, const PROPSPEC rgpspec[])
static HRESULT WINAPI	IPropertyStorage_fnReadPropertyNames (IPropertyStorage *iface, ULONG cpropid, const PROPID rgpropid[], LPOLESTR rglpwstrName[])
static HRESULT WINAPI	IPropertyStorage_fnWritePropertyNames (IPropertyStorage *iface, ULONG cpropid, const PROPID rgpropid[], const LPOLESTR rglpwstrName[])
static HRESULT WINAPI	IPropertyStorage_fnDeletePropertyNames (IPropertyStorage *iface, ULONG cpropid, const PROPID rgpropid[])
static HRESULT WINAPI	IPropertyStorage_fnCommit (IPropertyStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	IPropertyStorage_fnRevert (IPropertyStorage *iface)
static HRESULT WINAPI	IPropertyStorage_fnEnum (IPropertyStorage *iface, IEnumSTATPROPSTG **ppenum)
static HRESULT WINAPI	IPropertyStorage_fnSetTimes (IPropertyStorage *iface, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
static HRESULT WINAPI	IPropertyStorage_fnSetClass (IPropertyStorage *iface, REFCLSID clsid)
static HRESULT WINAPI	IPropertyStorage_fnStat (IPropertyStorage *iface, STATPROPSETSTG *statpsstg)
static int	PropertyStorage_PropNameCompare (const void *a, const void *b, void *extra)
static void	PropertyStorage_PropNameDestroy (void *k, void *d, void *extra)
static int	PropertyStorage_PropCompare (const void *a, const void *b, void *extra)
static void	PropertyStorage_PropertyDestroy (void *k, void *d, void *extra)
static HRESULT	PropertyStorage_ReadDictionary (PropertyStorage_impl *This, BYTE *ptr)
static void *__thiscall_wrapper	Allocate_CoTaskMemAlloc (void *this, ULONG size)
static HRESULT	PropertyStorage_ReadProperty (PROPVARIANT *prop, const BYTE *data, UINT codepage, void *(__thiscall_wrapper *allocate)(void *this, ULONG size), void *allocate_data)
static HRESULT	PropertyStorage_ReadHeaderFromStream (IStream *stm, PROPERTYSETHEADER *hdr)
static HRESULT	PropertyStorage_ReadFmtIdOffsetFromStream (IStream *stm, FORMATIDOFFSET *fmt)
static HRESULT	PropertyStorage_ReadSectionHeaderFromStream (IStream *stm, PROPERTYSECTIONHEADER *hdr)
static void	PropertyStorage_MakeHeader (PropertyStorage_impl *This, PROPERTYSETHEADER *hdr)
static void	PropertyStorage_MakeFmtIdOffset (PropertyStorage_impl *This, FORMATIDOFFSET *fmtOffset)
static void	PropertyStorage_MakeSectionHdr (DWORD cbSection, DWORD numProps, PROPERTYSECTIONHEADER *hdr)
static void	PropertyStorage_MakePropertyIdOffset (DWORD propid, DWORD dwOffset, PROPERTYIDOFFSET *propIdOffset)
static HRESULT	PropertStorage_WriteWStringToStream (IStream *stm, LPCWSTR str, DWORD len, DWORD *written)
static BOOL	PropertyStorage_DictionaryWriter (const void *key, const void *value, void *extra, void *closure)
static HRESULT	PropertyStorage_WriteDictionaryToStream (PropertyStorage_impl *This, DWORD *sectionOffset)
static HRESULT	PropertyStorage_WritePropertyToStream (PropertyStorage_impl *This, DWORD propNum, DWORD propid, const PROPVARIANT *var, DWORD *sectionOffset)
static BOOL	PropertyStorage_PropertiesWriter (const void *key, const void *value, void *extra, void *closure)
static HRESULT	PropertyStorage_WritePropertiesToStream (PropertyStorage_impl *This, DWORD startingPropNum, DWORD *sectionOffset)
static HRESULT	PropertyStorage_WriteHeadersToStream (PropertyStorage_impl *This)
static HRESULT	PropertyStorage_BaseConstruct (IStream *stm, REFFMTID rfmtid, DWORD grfMode, PropertyStorage_impl **pps)
static HRESULT	PropertyStorage_ConstructFromStream (IStream *stm, REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **pps)
static HRESULT	PropertyStorage_ConstructEmpty (IStream *stm, REFFMTID rfmtid, DWORD grfFlags, DWORD grfMode, IPropertyStorage **pps)
static HRESULT WINAPI	IPropertySetStorage_fnQueryInterface (IPropertySetStorage *ppstg, REFIID riid, void **ppvObject)
static ULONG WINAPI	IPropertySetStorage_fnAddRef (IPropertySetStorage *ppstg)
static ULONG WINAPI	IPropertySetStorage_fnRelease (IPropertySetStorage *ppstg)
static HRESULT WINAPI	IPropertySetStorage_fnCreate (IPropertySetStorage *ppstg, REFFMTID rfmtid, const CLSID *pclsid, DWORD grfFlags, DWORD grfMode, IPropertyStorage **ppprstg)
static HRESULT WINAPI	IPropertySetStorage_fnOpen (IPropertySetStorage *ppstg, REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **ppprstg)
static HRESULT WINAPI	IPropertySetStorage_fnDelete (IPropertySetStorage *ppstg, REFFMTID rfmtid)
static HRESULT WINAPI	IPropertySetStorage_fnEnum (IPropertySetStorage *ppstg, IEnumSTATPROPSETSTG **ppenum)
static HRESULT WINAPI	IEnumSTATPROPSETSTG_fnQueryInterface (IEnumSTATPROPSETSTG *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	IEnumSTATPROPSETSTG_fnAddRef (IEnumSTATPROPSETSTG *iface)
static ULONG WINAPI	IEnumSTATPROPSETSTG_fnRelease (IEnumSTATPROPSETSTG *iface)
static HRESULT WINAPI	IEnumSTATPROPSETSTG_fnNext (IEnumSTATPROPSETSTG *iface, ULONG celt, STATPROPSETSTG *rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	IEnumSTATPROPSETSTG_fnSkip (IEnumSTATPROPSETSTG *iface, ULONG celt)
static HRESULT WINAPI	IEnumSTATPROPSETSTG_fnReset (IEnumSTATPROPSETSTG *iface)
static HRESULT WINAPI	IEnumSTATPROPSETSTG_fnClone (IEnumSTATPROPSETSTG *iface, IEnumSTATPROPSETSTG **ppenum)
static HRESULT WINAPI	IEnumSTATPROPSTG_fnQueryInterface (IEnumSTATPROPSTG *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	IEnumSTATPROPSTG_fnAddRef (IEnumSTATPROPSTG *iface)
static ULONG WINAPI	IEnumSTATPROPSTG_fnRelease (IEnumSTATPROPSTG *iface)
static HRESULT WINAPI	IEnumSTATPROPSTG_fnNext (IEnumSTATPROPSTG *iface, ULONG celt, STATPROPSTG *rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	IEnumSTATPROPSTG_fnSkip (IEnumSTATPROPSTG *iface, ULONG celt)
static HRESULT WINAPI	IEnumSTATPROPSTG_fnReset (IEnumSTATPROPSTG *iface)
static HRESULT WINAPI	IEnumSTATPROPSTG_fnClone (IEnumSTATPROPSTG *iface, IEnumSTATPROPSTG **ppenum)
static void	prop_enum_copy_cb (IUnknown *parent, void *orig, void *dest)
static BOOL	prop_enum_stat (const void *k, const void *v, void *extra, void *arg)
HRESULT WINAPI	FmtIdToPropStgName (const FMTID *rfmtid, LPOLESTR str)
HRESULT WINAPI	PropStgNameToFmtId (const LPOLESTR str, FMTID *rfmtid)
static void *__cdecl	Allocate_PMemoryAllocator (void *this, ULONG cbSize)
BOOLEAN WINAPI	StgConvertPropertyToVariant (const SERIALIZEDPROPERTYVALUE *prop, USHORT CodePage, PROPVARIANT *pvar, void *pma)
SERIALIZEDPROPERTYVALUE *WINAPI	StgConvertVariantToProperty (const PROPVARIANT *pvar, USHORT CodePage, SERIALIZEDPROPERTYVALUE *pprop, ULONG *pcb, PROPID pid, BOOLEAN fReserved, ULONG *pcIndirect)
HRESULT WINAPI	StgCreatePropStg (IUnknown *unk, REFFMTID fmt, const CLSID *clsid, DWORD flags, DWORD reserved, IPropertyStorage **prop_stg)
HRESULT WINAPI	StgOpenPropStg (IUnknown *unk, REFFMTID fmt, DWORD flags, DWORD reserved, IPropertyStorage **prop_stg)

Variables
static const IPropertyStorageVtbl	IPropertyStorage_Vtbl
static const IEnumSTATPROPSETSTGVtbl	IEnumSTATPROPSETSTG_Vtbl
static const IEnumSTATPROPSTGVtbl	IEnumSTATPROPSTG_Vtbl
const IPropertySetStorageVtbl	IPropertySetStorage_Vtbl
static const WCHAR	szSummaryInfo []
static const WCHAR	szDocSummaryInfo []

Macro Definition Documentation

__thiscall_wrapper

#define __thiscall_wrapper   __cdecl

Definition at line 1039 of file stg_prop.c.

BITS_IN_CHARMASK

#define BITS_IN_CHARMASK   5

Definition at line 2619 of file stg_prop.c.

BITS_PER_BYTE

#define BITS_PER_BYTE   8

Definition at line 2617 of file stg_prop.c.

CFTAG_FMTID

#define CFTAG_FMTID   (-3L)

Definition at line 80 of file stg_prop.c.

CFTAG_MACINTOSH

#define CFTAG_MACINTOSH   (-2L)

Definition at line 79 of file stg_prop.c.

CFTAG_NODATA

#define CFTAG_NODATA   0L

Definition at line 81 of file stg_prop.c.

CFTAG_WINDOWS

#define CFTAG_WINDOWS   (-1L)

Definition at line 78 of file stg_prop.c.

CHARMASK

#define CHARMASK   0x1f

Definition at line 2618 of file stg_prop.c.

COBJMACROS

#define COBJMACROS

Definition at line 45 of file stg_prop.c.

CP_UNICODE

#define CP_UNICODE   1200

Definition at line 74 of file stg_prop.c.

MAX_VERSION_0_PROP_NAME_LENGTH

#define MAX_VERSION_0_PROP_NAME_LENGTH   256

Definition at line 76 of file stg_prop.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 46 of file stg_prop.c.

NUM_ALPHA_CHARS

#define NUM_ALPHA_CHARS   26

Definition at line 2620 of file stg_prop.c.

PropertyStorage_ByteSwapString

#define PropertyStorage_ByteSwapString	(		s,
			l
	)

Definition at line 986 of file stg_prop.c.

PROPSETHDR_BYTEORDER_MAGIC

#define PROPSETHDR_BYTEORDER_MAGIC   0xfffe

Definition at line 69 of file stg_prop.c.

PROPSETHDR_OSVER_KIND_MAC

#define PROPSETHDR_OSVER_KIND_MAC   1

Definition at line 71 of file stg_prop.c.

PROPSETHDR_OSVER_KIND_WIN16

#define PROPSETHDR_OSVER_KIND_WIN16   0

Definition at line 70 of file stg_prop.c.

PROPSETHDR_OSVER_KIND_WIN32

#define PROPSETHDR_OSVER_KIND_WIN32   2

Definition at line 72 of file stg_prop.c.

SECTIONHEADER_OFFSET

#define SECTIONHEADER_OFFSET   sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET)

Definition at line 1649 of file stg_prop.c.

Typedef Documentation

FORMATIDOFFSET

typedef struct tagFORMATIDOFFSET FORMATIDOFFSET

PROPERTYIDOFFSET

typedef struct tagPROPERTYIDOFFSET PROPERTYIDOFFSET

PROPERTYSECTIONHEADER

typedef struct tagPROPERTYSECTIONHEADER PROPERTYSECTIONHEADER

PROPERTYSETHEADER

typedef struct tagPROPERTYSETHEADER PROPERTYSETHEADER

PropertyStorage_impl

typedef struct tagPropertyStorage_impl PropertyStorage_impl

Definition at line 110 of file stg_prop.c.

Function Documentation

Allocate_CoTaskMemAlloc()

static void *__thiscall_wrapper Allocate_CoTaskMemAlloc ( void *  this, ULONG  size  )

static

Definition at line 1042 of file stg_prop.c.

{
    return CoTaskMemAlloc(size);
}

Referenced by PropertyStorage_ReadFromStream().

Allocate_PMemoryAllocator()

static void *__cdecl Allocate_PMemoryAllocator ( void *  this, ULONG  cbSize  )

static

Definition at line 2787 of file stg_prop.c.

{
    void* (__cdecl *fn)(void*,ULONG) = **(void***)this;
    return fn(this, cbSize);
}

Referenced by StgConvertPropertyToVariant().

create_EnumSTATPROPSETSTG()

static HRESULT create_EnumSTATPROPSETSTG ( StorageImpl *  This, IEnumSTATPROPSETSTG **  ppenum  )

static

Definition at line 2385 of file stg_prop.c.

{
    IStorage *stg = &This->base.IStorage_iface;
    IEnumSTATSTG *penum = NULL;
    STATSTG stat;
    ULONG count;
    HRESULT r;
    STATPROPSETSTG statpss;
    enumx_impl *enumx;
 
    TRACE("%p %p\n", This, ppenum);
 
    enumx = enumx_allocate(&IID_IEnumSTATPROPSETSTG,
                           &IEnumSTATPROPSETSTG_Vtbl,
                           sizeof (STATPROPSETSTG),
                           (IUnknown*)&This->base.IStorage_iface,
                           NULL);
 
    /* add all the property set elements into a list */
    r = IStorage_EnumElements(stg, 0, NULL, 0, &penum);
    if (FAILED(r))
    {
        enumx_Release(enumx);
        return E_OUTOFMEMORY;
    }
 
    while (1)
    {
        count = 0;
        r = IEnumSTATSTG_Next(penum, 1, &stat, &count);
        if (FAILED(r))
            break;
        if (!count)
            break;
        if (!stat.pwcsName)
            continue;
        if (stat.pwcsName[0] == 5 && stat.type == STGTY_STREAM)
        {
            PropStgNameToFmtId(stat.pwcsName, &statpss.fmtid);
            TRACE("adding %s (%s)\n", debugstr_w(stat.pwcsName),
                  debugstr_guid(&statpss.fmtid));
            statpss.mtime = stat.mtime;
            statpss.atime = stat.atime;
            statpss.ctime = stat.ctime;
            statpss.grfFlags = stat.grfMode;
            statpss.clsid = stat.clsid;
            enumx_add_element(enumx, &statpss);
        }
        CoTaskMemFree(stat.pwcsName);
    }
    IEnumSTATSTG_Release(penum);
 
    *ppenum = (IEnumSTATPROPSETSTG*) enumx;
 
    return S_OK;
}

Referenced by IPropertySetStorage_fnEnum().

create_EnumSTATPROPSTG()

static HRESULT create_EnumSTATPROPSTG ( PropertyStorage_impl *  This, IEnumSTATPROPSTG **  ppenum  )

static

Definition at line 2533 of file stg_prop.c.

{
    enumx_impl *enumx;
 
    TRACE("%p %p\n", This, ppenum);
 
    enumx = enumx_allocate(&IID_IEnumSTATPROPSTG,
                           &IEnumSTATPROPSTG_Vtbl,
                           sizeof (STATPROPSTG),
                           (IUnknown*)&This->IPropertyStorage_iface,
                           prop_enum_copy_cb);
 
    dictionary_enumerate(This->propid_to_prop, prop_enum_stat, enumx);
 
    *ppenum = (IEnumSTATPROPSTG*) enumx;
 
    return S_OK;
}

Referenced by IPropertyStorage_fnEnum().

FmtIdToPropStgName()

HRESULT WINAPI FmtIdToPropStgName	(	const FMTID *	rfmtid,
		LPOLESTR	str
	)

Definition at line 2635 of file stg_prop.c.

{
    static const char fmtMap[] = "abcdefghijklmnopqrstuvwxyz012345";
 
    TRACE("%s, %p\n", debugstr_guid(rfmtid), str);
 
    if (!rfmtid) return E_INVALIDARG;
    if (!str) return E_INVALIDARG;
 
    if (IsEqualGUID(&FMTID_SummaryInformation, rfmtid))
        lstrcpyW(str, szSummaryInfo);
    else if (IsEqualGUID(&FMTID_DocSummaryInformation, rfmtid))
        lstrcpyW(str, szDocSummaryInfo);
    else if (IsEqualGUID(&FMTID_UserDefinedProperties, rfmtid))
        lstrcpyW(str, szDocSummaryInfo);
    else
    {
        const BYTE *fmtptr;
        WCHAR *pstr = str;
        ULONG bitsRemaining = BITS_PER_BYTE;
 
        *pstr++ = 5;
        for (fmtptr = (const BYTE *)rfmtid; fmtptr < (const BYTE *)rfmtid + sizeof(FMTID); )
        {
            ULONG i = *fmtptr >> (BITS_PER_BYTE - bitsRemaining);
 
            if (bitsRemaining >= BITS_IN_CHARMASK)
            {
                *pstr = (WCHAR)(fmtMap[i & CHARMASK]);
                if (bitsRemaining == BITS_PER_BYTE && *pstr >= 'a' &&
                 *pstr <= 'z')
                    *pstr += 'A' - 'a';
                pstr++;
                bitsRemaining -= BITS_IN_CHARMASK;
                if (bitsRemaining == 0)
                {
                    fmtptr++;
                    bitsRemaining = BITS_PER_BYTE;
                }
            }
            else
            {
                if (++fmtptr < (const BYTE *)rfmtid + sizeof(FMTID))
                    i |= *fmtptr << bitsRemaining;
                *pstr++ = (WCHAR)(fmtMap[i & CHARMASK]);
                bitsRemaining += BITS_PER_BYTE - BITS_IN_CHARMASK;
            }
        }
        *pstr = 0;
    }
    TRACE("returning %s\n", debugstr_w(str));
    return S_OK;
}

Referenced by IPropertySetStorage_fnCreate(), IPropertySetStorage_fnDelete(), and IPropertySetStorage_fnOpen().

IEnumSTATPROPSETSTG_fnAddRef()

static ULONG WINAPI IEnumSTATPROPSETSTG_fnAddRef ( IEnumSTATPROPSETSTG *  iface )

static

Definition at line 2344 of file stg_prop.c.

{
    return enumx_AddRef((enumx_impl*)iface);
}

IEnumSTATPROPSETSTG_fnClone()

static HRESULT WINAPI IEnumSTATPROPSETSTG_fnClone ( IEnumSTATPROPSETSTG *  iface, IEnumSTATPROPSETSTG **  ppenum  )

static

Definition at line 2378 of file stg_prop.c.

{
    return enumx_Clone((enumx_impl*)iface, (enumx_impl**)ppenum);
}

IEnumSTATPROPSETSTG_fnNext()

static HRESULT WINAPI IEnumSTATPROPSETSTG_fnNext ( IEnumSTATPROPSETSTG *  iface, ULONG  celt, STATPROPSETSTG *  rgelt, ULONG *  pceltFetched  )

static

Definition at line 2356 of file stg_prop.c.

{
    return enumx_Next((enumx_impl*)iface, celt, rgelt, pceltFetched);
}

IEnumSTATPROPSETSTG_fnQueryInterface()

static HRESULT WINAPI IEnumSTATPROPSETSTG_fnQueryInterface ( IEnumSTATPROPSETSTG *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2336 of file stg_prop.c.

{
    return enumx_QueryInterface((enumx_impl*)iface, riid, ppvObject);
}

IEnumSTATPROPSETSTG_fnRelease()

static ULONG WINAPI IEnumSTATPROPSETSTG_fnRelease ( IEnumSTATPROPSETSTG *  iface )

static

Definition at line 2350 of file stg_prop.c.

{
    return enumx_Release((enumx_impl*)iface);
}

IEnumSTATPROPSETSTG_fnReset()

static HRESULT WINAPI IEnumSTATPROPSETSTG_fnReset ( IEnumSTATPROPSETSTG *  iface )

static

Definition at line 2372 of file stg_prop.c.

{
    return enumx_Reset((enumx_impl*)iface);
}

IEnumSTATPROPSETSTG_fnSkip()

static HRESULT WINAPI IEnumSTATPROPSETSTG_fnSkip ( IEnumSTATPROPSETSTG *  iface, ULONG  celt  )

static

Definition at line 2365 of file stg_prop.c.

{
    return enumx_Skip((enumx_impl*)iface, celt);
}

IEnumSTATPROPSTG_fnAddRef()

static ULONG WINAPI IEnumSTATPROPSTG_fnAddRef ( IEnumSTATPROPSTG *  iface )

static

Definition at line 2455 of file stg_prop.c.

{
    return enumx_AddRef((enumx_impl*)iface);
}

IEnumSTATPROPSTG_fnClone()

static HRESULT WINAPI IEnumSTATPROPSTG_fnClone ( IEnumSTATPROPSTG *  iface, IEnumSTATPROPSTG **  ppenum  )

static

Definition at line 2489 of file stg_prop.c.

{
    return enumx_Clone((enumx_impl*)iface, (enumx_impl**)ppenum);
}

IEnumSTATPROPSTG_fnNext()

static HRESULT WINAPI IEnumSTATPROPSTG_fnNext ( IEnumSTATPROPSTG *  iface, ULONG  celt, STATPROPSTG *  rgelt, ULONG *  pceltFetched  )

static

Definition at line 2467 of file stg_prop.c.

{
    return enumx_Next((enumx_impl*)iface, celt, rgelt, pceltFetched);
}

IEnumSTATPROPSTG_fnQueryInterface()

static HRESULT WINAPI IEnumSTATPROPSTG_fnQueryInterface ( IEnumSTATPROPSTG *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2447 of file stg_prop.c.

{
    return enumx_QueryInterface((enumx_impl*)iface, riid, ppvObject);
}

IEnumSTATPROPSTG_fnRelease()

static ULONG WINAPI IEnumSTATPROPSTG_fnRelease ( IEnumSTATPROPSTG *  iface )

static

Definition at line 2461 of file stg_prop.c.

{
    return enumx_Release((enumx_impl*)iface);
}

IEnumSTATPROPSTG_fnReset()

static HRESULT WINAPI IEnumSTATPROPSTG_fnReset ( IEnumSTATPROPSTG *  iface )

static

Definition at line 2483 of file stg_prop.c.

{
    return enumx_Reset((enumx_impl*)iface);
}

IEnumSTATPROPSTG_fnSkip()

static HRESULT WINAPI IEnumSTATPROPSTG_fnSkip ( IEnumSTATPROPSTG *  iface, ULONG  celt  )

static

Definition at line 2476 of file stg_prop.c.

{
    return enumx_Skip((enumx_impl*)iface, celt);
}

impl_from_IPropertySetStorage()

static StorageImpl * impl_from_IPropertySetStorage ( IPropertySetStorage *  iface )

inlinestatic

Definition at line 61 of file stg_prop.c.

{
    return CONTAINING_RECORD(iface, StorageImpl, base.IPropertySetStorage_iface);
}

Referenced by IPropertySetStorage_fnAddRef(), IPropertySetStorage_fnCreate(), IPropertySetStorage_fnDelete(), IPropertySetStorage_fnEnum(), IPropertySetStorage_fnOpen(), IPropertySetStorage_fnQueryInterface(), and IPropertySetStorage_fnRelease().

impl_from_IPropertyStorage()

static PropertyStorage_impl * impl_from_IPropertyStorage ( IPropertyStorage *  iface )

inlinestatic

Definition at line 174 of file stg_prop.c.

{
    return CONTAINING_RECORD(iface, PropertyStorage_impl, IPropertyStorage_iface);
}

Referenced by IPropertyStorage_fnAddRef(), IPropertyStorage_fnCommit(), IPropertyStorage_fnDeleteMultiple(), IPropertyStorage_fnDeletePropertyNames(), IPropertyStorage_fnEnum(), IPropertyStorage_fnQueryInterface(), IPropertyStorage_fnReadMultiple(), IPropertyStorage_fnReadPropertyNames(), IPropertyStorage_fnRelease(), IPropertyStorage_fnRevert(), IPropertyStorage_fnSetClass(), IPropertyStorage_fnStat(), IPropertyStorage_fnWriteMultiple(), IPropertyStorage_fnWritePropertyNames(), and prop_enum_copy_cb().

IPropertySetStorage_fnAddRef()

static ULONG WINAPI IPropertySetStorage_fnAddRef ( IPropertySetStorage *  ppstg )

static

Definition at line 2174 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    return IStorage_AddRef( &This->base.IStorage_iface );
}

IPropertySetStorage_fnCreate()

static HRESULT WINAPI IPropertySetStorage_fnCreate ( IPropertySetStorage *  ppstg, REFFMTID  rfmtid, const CLSID *  pclsid, DWORD  grfFlags, DWORD  grfMode, IPropertyStorage **  ppprstg  )

static

Definition at line 2196 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
    IStream *stm = NULL;
    HRESULT r;
 
    TRACE("%p %s %08x %08x %p\n", This, debugstr_guid(rfmtid), grfFlags,
     grfMode, ppprstg);
 
    /* be picky */
    if (grfMode != (STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE))
    {
        r = STG_E_INVALIDFLAG;
        goto end;
    }
 
    if (!rfmtid)
    {
        r = E_INVALIDARG;
        goto end;
    }
 
    /* FIXME: if (grfFlags & PROPSETFLAG_NONSIMPLE), we need to create a
     * storage, not a stream.  For now, disallow it.
     */
    if (grfFlags & PROPSETFLAG_NONSIMPLE)
    {
        FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
        r = STG_E_INVALIDFLAG;
        goto end;
    }
 
    r = FmtIdToPropStgName(rfmtid, name);
    if (FAILED(r))
        goto end;
 
    r = IStorage_CreateStream( &This->base.IStorage_iface, name, grfMode, 0, 0, &stm );
    if (FAILED(r))
        goto end;
 
    r = PropertyStorage_ConstructEmpty(stm, rfmtid, grfFlags, grfMode, ppprstg);
 
    IStream_Release( stm );
 
end:
    TRACE("returning 0x%08x\n", r);
    return r;
}

IPropertySetStorage_fnDelete()

static HRESULT WINAPI IPropertySetStorage_fnDelete ( IPropertySetStorage *  ppstg, REFFMTID  rfmtid  )

static

Definition at line 2302 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
    HRESULT r;
 
    TRACE("%p %s\n", This, debugstr_guid(rfmtid));
 
    if (!rfmtid)
        return E_INVALIDARG;
 
    r = FmtIdToPropStgName(rfmtid, name);
    if (FAILED(r))
        return r;
 
    return IStorage_DestroyElement(&This->base.IStorage_iface, name);
}

IPropertySetStorage_fnEnum()

static HRESULT WINAPI IPropertySetStorage_fnEnum ( IPropertySetStorage *  ppstg, IEnumSTATPROPSETSTG **  ppenum  )

static

Definition at line 2325 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    return create_EnumSTATPROPSETSTG(This, ppenum);
}

IPropertySetStorage_fnOpen()

static HRESULT WINAPI IPropertySetStorage_fnOpen ( IPropertySetStorage *  ppstg, REFFMTID  rfmtid, DWORD  grfMode, IPropertyStorage **  ppprstg  )

static

Definition at line 2255 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    IStream *stm = NULL;
    WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
    HRESULT r;
 
    TRACE("%p %s %08x %p\n", This, debugstr_guid(rfmtid), grfMode, ppprstg);
 
    /* be picky */
    if (grfMode != (STGM_READWRITE|STGM_SHARE_EXCLUSIVE) &&
        grfMode != (STGM_READ|STGM_SHARE_EXCLUSIVE))
    {
        r = STG_E_INVALIDFLAG;
        goto end;
    }
 
    if (!rfmtid)
    {
        r = E_INVALIDARG;
        goto end;
    }
 
    r = FmtIdToPropStgName(rfmtid, name);
    if (FAILED(r))
        goto end;
 
    r = IStorage_OpenStream( &This->base.IStorage_iface, name, 0, grfMode, 0, &stm );
    if (FAILED(r))
        goto end;
 
    r = PropertyStorage_ConstructFromStream(stm, rfmtid, grfMode, ppprstg);
 
    IStream_Release( stm );
 
end:
    TRACE("returning 0x%08x\n", r);
    return r;
}

IPropertySetStorage_fnQueryInterface()

static HRESULT WINAPI IPropertySetStorage_fnQueryInterface ( IPropertySetStorage *  ppstg, REFIID  riid, void **  ppvObject  )

static

Definition at line 2160 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    return IStorage_QueryInterface( &This->base.IStorage_iface, riid, ppvObject );
}

IPropertySetStorage_fnRelease()

static ULONG WINAPI IPropertySetStorage_fnRelease ( IPropertySetStorage *  ppstg )

static

Definition at line 2186 of file stg_prop.c.

{
    StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
    return IStorage_Release( &This->base.IStorage_iface );
}

IPropertyStorage_fnAddRef()

static ULONG WINAPI IPropertyStorage_fnAddRef ( IPropertyStorage *  iface )

static

Definition at line 210 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    return InterlockedIncrement(&This->ref);
}

IPropertyStorage_fnCommit()

static HRESULT WINAPI IPropertyStorage_fnCommit ( IPropertyStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 809 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    HRESULT hr;
 
    TRACE("(%p, 0x%08x)\n", iface, grfCommitFlags);
 
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    EnterCriticalSection(&This->cs);
    if (This->dirty)
        hr = PropertyStorage_WriteToStream(This);
    else
        hr = S_OK;
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnDeleteMultiple()

static HRESULT WINAPI IPropertyStorage_fnDeleteMultiple ( IPropertyStorage *  iface, ULONG  cpspec, const PROPSPEC  rgpspec[]  )

static

Definition at line 653 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    ULONG i;
    HRESULT hr;
 
    TRACE("(%p, %d, %p)\n", iface, cpspec, rgpspec);
 
    if (cpspec && !rgpspec)
        return E_INVALIDARG;
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    hr = S_OK;
    EnterCriticalSection(&This->cs);
    This->dirty = TRUE;
    for (i = 0; i < cpspec; i++)
    {
        if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
        {
            void *propid;
 
            if (dictionary_find(This->name_to_propid, rgpspec[i].u.lpwstr, &propid))
                dictionary_remove(This->propid_to_prop, propid);
        }
        else
        {
            if (rgpspec[i].u.propid >= PID_FIRST_USABLE &&
             rgpspec[i].u.propid < PID_MIN_READONLY)
                dictionary_remove(This->propid_to_prop, UlongToPtr(rgpspec[i].u.propid));
            else
                hr = STG_E_INVALIDPARAMETER;
        }
    }
    if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
        IPropertyStorage_Commit(iface, STGC_DEFAULT);
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnDeletePropertyNames()

static HRESULT WINAPI IPropertyStorage_fnDeletePropertyNames ( IPropertyStorage *  iface, ULONG  cpropid, const PROPID  rgpropid[]  )

static

Definition at line 772 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    ULONG i;
    HRESULT hr;
 
    TRACE("(%p, %d, %p)\n", iface, cpropid, rgpropid);
 
    if (cpropid && !rgpropid)
        return E_INVALIDARG;
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    hr = S_OK;
    EnterCriticalSection(&This->cs);
    This->dirty = TRUE;
    for (i = 0; i < cpropid; i++)
    {
        LPWSTR name = NULL;
 
        if (dictionary_find(This->propid_to_name, UlongToPtr(rgpropid[i]), (void **)&name))
        {
            dictionary_remove(This->propid_to_name, UlongToPtr(rgpropid[i]));
            dictionary_remove(This->name_to_propid, name);
        }
    }
    if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
        IPropertyStorage_Commit(iface, STGC_DEFAULT);
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnEnum()

static HRESULT WINAPI IPropertyStorage_fnEnum ( IPropertyStorage *  iface, IEnumSTATPROPSTG **  ppenum  )

static

Definition at line 857 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    return create_EnumSTATPROPSTG(This, ppenum);
}

IPropertyStorage_fnQueryInterface()

static HRESULT WINAPI IPropertyStorage_fnQueryInterface ( IPropertyStorage *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 182 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppvObject);
 
    if (!ppvObject)
        return E_INVALIDARG;
 
    *ppvObject = 0;
 
    if (IsEqualGUID(&IID_IUnknown, riid) ||
        IsEqualGUID(&IID_IPropertyStorage, riid))
    {
        IPropertyStorage_AddRef(iface);
        *ppvObject = iface;
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

IPropertyStorage_fnReadMultiple()

static HRESULT WINAPI IPropertyStorage_fnReadMultiple ( IPropertyStorage *  iface, ULONG  cpspec, const PROPSPEC  rgpspec[], PROPVARIANT  rgpropvar[]  )

static

Definition at line 295 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    HRESULT hr = S_OK;
    ULONG i;
 
    TRACE("(%p, %d, %p, %p)\n", iface, cpspec, rgpspec, rgpropvar);
 
    if (!cpspec)
        return S_FALSE;
    if (!rgpspec || !rgpropvar)
        return E_INVALIDARG;
    EnterCriticalSection(&This->cs);
    for (i = 0; i < cpspec; i++)
    {
        PropVariantInit(&rgpropvar[i]);
        if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
        {
            PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
             rgpspec[i].u.lpwstr);
 
            if (prop)
                PropertyStorage_PropVariantCopy(&rgpropvar[i], prop, GetACP(),
                 This->codePage);
        }
        else
        {
            switch (rgpspec[i].u.propid)
            {
                case PID_CODEPAGE:
                    rgpropvar[i].vt = VT_I2;
                    rgpropvar[i].u.iVal = This->codePage;
                    break;
                case PID_LOCALE:
                    rgpropvar[i].vt = VT_I4;
                    rgpropvar[i].u.lVal = This->locale;
                    break;
                default:
                {
                    PROPVARIANT *prop = PropertyStorage_FindProperty(This,
                     rgpspec[i].u.propid);
 
                    if (prop)
                        PropertyStorage_PropVariantCopy(&rgpropvar[i], prop,
                         GetACP(), This->codePage);
                    else
                        hr = S_FALSE;
                }
            }
        }
    }
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnReadPropertyNames()

static HRESULT WINAPI IPropertyStorage_fnReadPropertyNames ( IPropertyStorage *  iface, ULONG  cpropid, const PROPID  rgpropid[], LPOLESTR  rglpwstrName[]  )

static

Definition at line 698 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    ULONG i;
    HRESULT hr = S_FALSE;
 
    TRACE("(%p, %d, %p, %p)\n", iface, cpropid, rgpropid, rglpwstrName);
 
    if (cpropid && (!rgpropid || !rglpwstrName))
        return E_INVALIDARG;
    EnterCriticalSection(&This->cs);
    for (i = 0; i < cpropid && SUCCEEDED(hr); i++)
    {
        LPWSTR name = PropertyStorage_FindPropertyNameById(This, rgpropid[i]);
 
        if (name)
        {
            size_t len = lstrlenW(name);
 
            hr = S_OK;
            rglpwstrName[i] = CoTaskMemAlloc((len + 1) * sizeof(WCHAR));
            if (rglpwstrName[i])
                memcpy(rglpwstrName[i], name, (len + 1) * sizeof(WCHAR));
            else
                hr = STG_E_INSUFFICIENTMEMORY;
        }
        else
            rglpwstrName[i] = NULL;
    }
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnRelease()

static ULONG WINAPI IPropertyStorage_fnRelease ( IPropertyStorage *  iface )

static

Definition at line 220 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    ULONG ref;
 
    ref = InterlockedDecrement(&This->ref);
    if (ref == 0)
    {
        TRACE("Destroying %p\n", This);
        if (This->dirty)
            IPropertyStorage_Commit(iface, STGC_DEFAULT);
        IStream_Release(This->stm);
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        PropertyStorage_DestroyDictionaries(This);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return ref;
}

IPropertyStorage_fnRevert()

static HRESULT WINAPI IPropertyStorage_fnRevert ( IPropertyStorage *  iface )

static

Definition at line 832 of file stg_prop.c.

{
    HRESULT hr;
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
 
    TRACE("%p\n", iface);
 
    EnterCriticalSection(&This->cs);
    if (This->dirty)
    {
        PropertyStorage_DestroyDictionaries(This);
        hr = PropertyStorage_CreateDictionaries(This);
        if (SUCCEEDED(hr))
            hr = PropertyStorage_ReadFromStream(This);
    }
    else
        hr = S_OK;
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnSetClass()

static HRESULT WINAPI IPropertyStorage_fnSetClass ( IPropertyStorage *  iface, REFCLSID  clsid  )

static

Definition at line 881 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
 
    TRACE("%p, %s\n", iface, debugstr_guid(clsid));
 
    if (!clsid)
        return E_INVALIDARG;
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    This->clsid = *clsid;
    This->dirty = TRUE;
    if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
        IPropertyStorage_Commit(iface, STGC_DEFAULT);
    return S_OK;
}

IPropertyStorage_fnSetTimes()

static HRESULT WINAPI IPropertyStorage_fnSetTimes ( IPropertyStorage *  iface, const FILETIME *  pctime, const FILETIME *  patime, const FILETIME *  pmtime  )

static

Definition at line 868 of file stg_prop.c.

{
    FIXME("\n");
    return E_NOTIMPL;
}

IPropertyStorage_fnStat()

static HRESULT WINAPI IPropertyStorage_fnStat ( IPropertyStorage *  iface, STATPROPSETSTG *  statpsstg  )

static

Definition at line 903 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    STATSTG stat;
    HRESULT hr;
 
    TRACE("%p, %p\n", iface, statpsstg);
 
    if (!statpsstg)
        return E_INVALIDARG;
 
    hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
    if (SUCCEEDED(hr))
    {
        statpsstg->fmtid = This->fmtid;
        statpsstg->clsid = This->clsid;
        statpsstg->grfFlags = This->grfFlags;
        statpsstg->mtime = stat.mtime;
        statpsstg->ctime = stat.ctime;
        statpsstg->atime = stat.atime;
        statpsstg->dwOSVersion = This->originatorOS;
    }
    return hr;
}

IPropertyStorage_fnWriteMultiple()

static HRESULT WINAPI IPropertyStorage_fnWriteMultiple ( IPropertyStorage *  iface, ULONG  cpspec, const PROPSPEC  rgpspec[], const PROPVARIANT  rgpropvar[], PROPID  propidNameFirst  )

static

Definition at line 552 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    HRESULT hr = S_OK;
    ULONG i;
 
    TRACE("(%p, %d, %p, %p)\n", iface, cpspec, rgpspec, rgpropvar);
 
    if (cpspec && (!rgpspec || !rgpropvar))
        return E_INVALIDARG;
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    EnterCriticalSection(&This->cs);
    This->dirty = TRUE;
    This->originatorOS = (DWORD)MAKELONG(LOWORD(GetVersion()),
     PROPSETHDR_OSVER_KIND_WIN32) ;
    for (i = 0; i < cpspec; i++)
    {
        if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
        {
            PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
             rgpspec[i].u.lpwstr);
 
            if (prop)
                PropVariantCopy(prop, &rgpropvar[i]);
            else
            {
                /* Note that I don't do the special cases here that I do below,
                 * because naming the special PIDs isn't supported.
                 */
                if (propidNameFirst < PID_FIRST_USABLE ||
                 propidNameFirst >= PID_MIN_READONLY)
                    hr = STG_E_INVALIDPARAMETER;
                else
                {
                    PROPID nextId = max(propidNameFirst, This->highestProp + 1);
 
                    hr = PropertyStorage_StoreNameWithId(This,
                     (LPCSTR)rgpspec[i].u.lpwstr, CP_UNICODE, nextId);
                    if (SUCCEEDED(hr))
                        hr = PropertyStorage_StorePropWithId(This, nextId,
                         &rgpropvar[i], GetACP());
                }
            }
        }
        else
        {
            switch (rgpspec[i].u.propid)
            {
            case PID_DICTIONARY:
                /* Can't set the dictionary */
                hr = STG_E_INVALIDPARAMETER;
                break;
            case PID_CODEPAGE:
                /* Can only set the code page if nothing else has been set */
                if (dictionary_num_entries(This->propid_to_prop) == 0 &&
                 rgpropvar[i].vt == VT_I2)
                {
                    This->codePage = rgpropvar[i].u.iVal;
                    if (This->codePage == CP_UNICODE)
                        This->grfFlags &= ~PROPSETFLAG_ANSI;
                    else
                        This->grfFlags |= PROPSETFLAG_ANSI;
                }
                else
                    hr = STG_E_INVALIDPARAMETER;
                break;
            case PID_LOCALE:
                /* Can only set the locale if nothing else has been set */
                if (dictionary_num_entries(This->propid_to_prop) == 0 &&
                 rgpropvar[i].vt == VT_I4)
                    This->locale = rgpropvar[i].u.lVal;
                else
                    hr = STG_E_INVALIDPARAMETER;
                break;
            case PID_ILLEGAL:
                /* silently ignore like MSDN says */
                break;
            default:
                if (rgpspec[i].u.propid >= PID_MIN_READONLY)
                    hr = STG_E_INVALIDPARAMETER;
                else
                    hr = PropertyStorage_StorePropWithId(This,
                     rgpspec[i].u.propid, &rgpropvar[i], GetACP());
            }
        }
    }
    if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
        IPropertyStorage_Commit(iface, STGC_DEFAULT);
    LeaveCriticalSection(&This->cs);
    return hr;
}

IPropertyStorage_fnWritePropertyNames()

static HRESULT WINAPI IPropertyStorage_fnWritePropertyNames ( IPropertyStorage *  iface, ULONG  cpropid, const PROPID  rgpropid[], const LPOLESTR  rglpwstrName[]  )

static

Definition at line 738 of file stg_prop.c.

{
    PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
    ULONG i;
    HRESULT hr;
 
    TRACE("(%p, %d, %p, %p)\n", iface, cpropid, rgpropid, rglpwstrName);
 
    if (cpropid && (!rgpropid || !rglpwstrName))
        return E_INVALIDARG;
    if (!(This->grfMode & STGM_READWRITE))
        return STG_E_ACCESSDENIED;
    hr = S_OK;
    EnterCriticalSection(&This->cs);
    This->dirty = TRUE;
    for (i = 0; SUCCEEDED(hr) && i < cpropid; i++)
    {
        if (rgpropid[i] != PID_ILLEGAL)
            hr = PropertyStorage_StoreNameWithId(This, (LPCSTR)rglpwstrName[i],
             CP_UNICODE, rgpropid[i]);
    }
    if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
        IPropertyStorage_Commit(iface, STGC_DEFAULT);
    LeaveCriticalSection(&This->cs);
    return hr;
}

prop_enum_copy_cb()

static void prop_enum_copy_cb ( IUnknown *  parent, void *  orig, void *  dest  )

static

Definition at line 2496 of file stg_prop.c.

{
    PropertyStorage_impl *storage = impl_from_IPropertyStorage((IPropertyStorage*)parent);
    STATPROPSTG *src_prop = orig;
    STATPROPSTG *dest_prop = dest;
    LPWSTR name;
 
    dest_prop->propid = src_prop->propid;
    dest_prop->vt = src_prop->vt;
    dest_prop->lpwstrName = NULL;
 
    if (dictionary_find(storage->propid_to_name, UlongToPtr(src_prop->propid), (void**)&name))
    {
        DWORD size = (lstrlenW(name) + 1) * sizeof(WCHAR);
 
        dest_prop->lpwstrName = CoTaskMemAlloc(size);
        if (!dest_prop->lpwstrName) return;
        memcpy(dest_prop->lpwstrName, name, size);
    }
}

Referenced by create_EnumSTATPROPSTG().

prop_enum_stat()

static BOOL prop_enum_stat ( const void *  k, const void *  v, void *  extra, void *  arg  )

static

Definition at line 2517 of file stg_prop.c.

{
    enumx_impl *enumx = arg;
    PROPID propid = PtrToUlong(k);
    const PROPVARIANT *prop = v;
    STATPROPSTG stat;
 
    stat.lpwstrName = NULL;
    stat.propid = propid;
    stat.vt = prop->vt;
 
    enumx_add_element(enumx, &stat);
 
    return TRUE;
}

Referenced by create_EnumSTATPROPSTG().

PropertStorage_WriteWStringToStream()

static HRESULT PropertStorage_WriteWStringToStream ( IStream *  stm, LPCWSTR  str, DWORD  len, DWORD *  written  )

inlinestatic

Definition at line 1567 of file stg_prop.c.

{
#ifdef WORDS_BIGENDIAN
    WCHAR *leStr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    HRESULT hr;
 
    if (!leStr)
        return E_OUTOFMEMORY;
    memcpy(leStr, str, len * sizeof(WCHAR));
    PropertyStorage_ByteSwapString(leStr, len);
    hr = IStream_Write(stm, leStr, len, written);
    HeapFree(GetProcessHeap(), 0, leStr);
    return hr;
#else
    return IStream_Write(stm, str, len, written);
#endif
}

Referenced by PropertyStorage_DictionaryWriter().

PropertyStorage_BaseConstruct()

static HRESULT PropertyStorage_BaseConstruct ( IStream *  stm, REFFMTID  rfmtid, DWORD  grfMode, PropertyStorage_impl **  pps  )

static

Definition at line 2068 of file stg_prop.c.

{
    HRESULT hr = S_OK;
 
    assert(pps);
    assert(rfmtid);
    *pps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof **pps);
    if (!*pps)
        return E_OUTOFMEMORY;
 
    (*pps)->IPropertyStorage_iface.lpVtbl = &IPropertyStorage_Vtbl;
    (*pps)->ref = 1;
    InitializeCriticalSection(&(*pps)->cs);
    (*pps)->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PropertyStorage_impl.cs");
    (*pps)->stm = stm;
    (*pps)->fmtid = *rfmtid;
    (*pps)->grfMode = grfMode;
 
    hr = PropertyStorage_CreateDictionaries(*pps);
    if (FAILED(hr))
    {
        (*pps)->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&(*pps)->cs);
        HeapFree(GetProcessHeap(), 0, *pps);
        *pps = NULL;
    }
    else IStream_AddRef( stm );
 
    return hr;
}

Referenced by PropertyStorage_ConstructEmpty(), and PropertyStorage_ConstructFromStream().

PropertyStorage_ConstructEmpty()

static HRESULT PropertyStorage_ConstructEmpty ( IStream *  stm, REFFMTID  rfmtid, DWORD  grfFlags, DWORD  grfMode, IPropertyStorage **  pps  )

static

Definition at line 2122 of file stg_prop.c.

{
    PropertyStorage_impl *ps;
    HRESULT hr;
 
    assert(pps);
    hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
    if (SUCCEEDED(hr))
    {
        ps->format = 0;
        ps->grfFlags = grfFlags;
        if (ps->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
            ps->format = 1;
        /* default to Unicode unless told not to, as specified on msdn */
        if (ps->grfFlags & PROPSETFLAG_ANSI)
            ps->codePage = GetACP();
        else
            ps->codePage = CP_UNICODE;
        ps->locale = LOCALE_SYSTEM_DEFAULT;
        TRACE("Code page is %d, locale is %d\n", ps->codePage, ps->locale);
        *pps = &ps->IPropertyStorage_iface;
        TRACE("PropertyStorage %p constructed\n", ps);
        hr = S_OK;
    }
    return hr;
}

Referenced by IPropertySetStorage_fnCreate(), and StgCreatePropStg().

PropertyStorage_ConstructFromStream()

static HRESULT PropertyStorage_ConstructFromStream ( IStream *  stm, REFFMTID  rfmtid, DWORD  grfMode, IPropertyStorage **  pps  )

static

Definition at line 2100 of file stg_prop.c.

{
    PropertyStorage_impl *ps;
    HRESULT hr;
 
    assert(pps);
    hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
    if (SUCCEEDED(hr))
    {
        hr = PropertyStorage_ReadFromStream(ps);
        if (SUCCEEDED(hr))
        {
            *pps = &ps->IPropertyStorage_iface;
            TRACE("PropertyStorage %p constructed\n", ps);
            hr = S_OK;
        }
        else IPropertyStorage_Release( &ps->IPropertyStorage_iface );
    }
    return hr;
}

Referenced by IPropertySetStorage_fnOpen(), and StgOpenPropStg().

PropertyStorage_CreateDictionaries()

static HRESULT PropertyStorage_CreateDictionaries ( PropertyStorage_impl *  This )

static

Definition at line 2036 of file stg_prop.c.

{
    HRESULT hr = S_OK;
 
    This->name_to_propid = dictionary_create(
     PropertyStorage_PropNameCompare, PropertyStorage_PropNameDestroy,
     This);
    if (!This->name_to_propid)
    {
        hr = STG_E_INSUFFICIENTMEMORY;
        goto end;
    }
    This->propid_to_name = dictionary_create(PropertyStorage_PropCompare,
     NULL, This);
    if (!This->propid_to_name)
    {
        hr = STG_E_INSUFFICIENTMEMORY;
        goto end;
    }
    This->propid_to_prop = dictionary_create(PropertyStorage_PropCompare,
     PropertyStorage_PropertyDestroy, This);
    if (!This->propid_to_prop)
    {
        hr = STG_E_INSUFFICIENTMEMORY;
        goto end;
    }
end:
    if (FAILED(hr))
        PropertyStorage_DestroyDictionaries(This);
    return hr;
}

Referenced by IPropertyStorage_fnRevert(), and PropertyStorage_BaseConstruct().

PropertyStorage_DestroyDictionaries()

static void PropertyStorage_DestroyDictionaries ( PropertyStorage_impl *  This )

static

Definition at line 2026 of file stg_prop.c.

{
    dictionary_destroy(This->name_to_propid);
    This->name_to_propid = NULL;
    dictionary_destroy(This->propid_to_name);
    This->propid_to_name = NULL;
    dictionary_destroy(This->propid_to_prop);
    This->propid_to_prop = NULL;
}

Referenced by IPropertyStorage_fnRelease(), IPropertyStorage_fnRevert(), and PropertyStorage_CreateDictionaries().

PropertyStorage_DictionaryWriter()

static BOOL PropertyStorage_DictionaryWriter ( const void *  key, const void *  value, void *  extra, void *  closure  )

static

Definition at line 1592 of file stg_prop.c.

{
    PropertyStorage_impl *This = extra;
    struct DictionaryClosure *c = closure;
    DWORD propid;
    ULONG count;
 
    assert(key);
    assert(closure);
    StorageUtl_WriteDWord((LPBYTE)&propid, 0, PtrToUlong(value));
    c->hr = IStream_Write(This->stm, &propid, sizeof(propid), &count);
    if (FAILED(c->hr))
        goto end;
    c->bytesWritten += sizeof(DWORD);
    if (This->codePage == CP_UNICODE)
    {
        DWORD keyLen, pad = 0;
 
        StorageUtl_WriteDWord((LPBYTE)&keyLen, 0,
         (lstrlenW((LPCWSTR)key) + 1) * sizeof(WCHAR));
        c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
        if (FAILED(c->hr))
            goto end;
        c->bytesWritten += sizeof(DWORD);
        c->hr = PropertStorage_WriteWStringToStream(This->stm, key, keyLen,
         &count);
        if (FAILED(c->hr))
            goto end;
        c->bytesWritten += keyLen * sizeof(WCHAR);
        if (keyLen % sizeof(DWORD))
        {
            c->hr = IStream_Write(This->stm, &pad,
             sizeof(DWORD) - keyLen % sizeof(DWORD), &count);
            if (FAILED(c->hr))
                goto end;
            c->bytesWritten += sizeof(DWORD) - keyLen % sizeof(DWORD);
        }
    }
    else
    {
        DWORD keyLen;
 
        StorageUtl_WriteDWord((LPBYTE)&keyLen, 0, strlen((LPCSTR)key) + 1);
        c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
        if (FAILED(c->hr))
            goto end;
        c->bytesWritten += sizeof(DWORD);
        c->hr = IStream_Write(This->stm, key, keyLen, &count);
        if (FAILED(c->hr))
            goto end;
        c->bytesWritten += keyLen;
    }
end:
    return SUCCEEDED(c->hr);
}

Referenced by PropertyStorage_WriteDictionaryToStream().

PropertyStorage_FindProperty()

static PROPVARIANT * PropertyStorage_FindProperty ( PropertyStorage_impl *  This, DWORD  propid  )

static

Definition at line 241 of file stg_prop.c.

{
    PROPVARIANT *ret = NULL;
 
    dictionary_find(This->propid_to_prop, UlongToPtr(propid), (void **)&ret);
    TRACE("returning %p\n", ret);
    return ret;
}

Referenced by IPropertyStorage_fnReadMultiple(), PropertyStorage_FindPropertyByName(), and PropertyStorage_StorePropWithId().

PropertyStorage_FindPropertyByName()

static PROPVARIANT * PropertyStorage_FindPropertyByName ( PropertyStorage_impl *  This, LPCWSTR  name  )

static

Definition at line 252 of file stg_prop.c.

{
    PROPVARIANT *ret = NULL;
    void *propid;
 
    if (!name)
        return NULL;
    if (This->codePage == CP_UNICODE)
    {
        if (dictionary_find(This->name_to_propid, name, &propid))
            ret = PropertyStorage_FindProperty(This, PtrToUlong(propid));
    }
    else
    {
        LPSTR ansiName;
        HRESULT hr = PropertyStorage_StringCopy((LPCSTR)name, CP_UNICODE,
         &ansiName, This->codePage);
 
        if (SUCCEEDED(hr))
        {
            if (dictionary_find(This->name_to_propid, ansiName, &propid))
                ret = PropertyStorage_FindProperty(This, PtrToUlong(propid));
            CoTaskMemFree(ansiName);
        }
    }
    TRACE("returning %p\n", ret);
    return ret;
}

Referenced by IPropertyStorage_fnReadMultiple(), and IPropertyStorage_fnWriteMultiple().

PropertyStorage_FindPropertyNameById()

static LPWSTR PropertyStorage_FindPropertyNameById ( PropertyStorage_impl *  This, DWORD  propid  )

static

Definition at line 282 of file stg_prop.c.

{
    LPWSTR ret = NULL;
 
    dictionary_find(This->propid_to_name, UlongToPtr(propid), (void **)&ret);
    TRACE("returning %p\n", ret);
    return ret;
}

Referenced by IPropertyStorage_fnReadPropertyNames().

PropertyStorage_MakeFmtIdOffset()

static void PropertyStorage_MakeFmtIdOffset ( PropertyStorage_impl *  This, FORMATIDOFFSET *  fmtOffset  )

static

Definition at line 1540 of file stg_prop.c.

{
    assert(fmtOffset);
    StorageUtl_WriteGUID((BYTE *)fmtOffset, 0, &This->fmtid);
    StorageUtl_WriteDWord((BYTE *)fmtOffset, offsetof(FORMATIDOFFSET, dwOffset),
     sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET));
}

Referenced by PropertyStorage_WriteHeadersToStream().

PropertyStorage_MakeHeader()

static void PropertyStorage_MakeHeader ( PropertyStorage_impl *  This, PROPERTYSETHEADER *  hdr  )

static

Definition at line 1528 of file stg_prop.c.

{
    assert(hdr);
    StorageUtl_WriteWord((BYTE *)&hdr->wByteOrder, 0,
     PROPSETHDR_BYTEORDER_MAGIC);
    StorageUtl_WriteWord((BYTE *)&hdr->wFormat, 0, This->format);
    StorageUtl_WriteDWord((BYTE *)&hdr->dwOSVer, 0, This->originatorOS);
    StorageUtl_WriteGUID((BYTE *)&hdr->clsid, 0, &This->clsid);
    StorageUtl_WriteDWord((BYTE *)&hdr->reserved, 0, 1);
}

Referenced by PropertyStorage_WriteHeadersToStream().

PropertyStorage_MakePropertyIdOffset()

static void PropertyStorage_MakePropertyIdOffset ( DWORD  propid, DWORD  dwOffset, PROPERTYIDOFFSET *  propIdOffset  )

static

Definition at line 1558 of file stg_prop.c.

{
    assert(propIdOffset);
    StorageUtl_WriteDWord((BYTE *)propIdOffset, 0, propid);
    StorageUtl_WriteDWord((BYTE *)propIdOffset,
     offsetof(PROPERTYIDOFFSET, dwOffset), dwOffset);
}

Referenced by PropertyStorage_WriteDictionaryToStream(), and PropertyStorage_WritePropertyToStream().

PropertyStorage_MakeSectionHdr()

static void PropertyStorage_MakeSectionHdr ( DWORD  cbSection, DWORD  numProps, PROPERTYSECTIONHEADER *  hdr  )

static

Definition at line 1549 of file stg_prop.c.

{
    assert(hdr);
    StorageUtl_WriteDWord((BYTE *)hdr, 0, cbSection);
    StorageUtl_WriteDWord((BYTE *)hdr,
     offsetof(PROPERTYSECTIONHEADER, cProperties), numProps);
}

Referenced by PropertyStorage_WriteToStream().

PropertyStorage_PropCompare()

static int PropertyStorage_PropCompare ( const void *  a, const void *  b, void *  extra  )

static

Definition at line 958 of file stg_prop.c.

{
    TRACE("(%d, %d)\n", PtrToUlong(a), PtrToUlong(b));
    return PtrToUlong(a) - PtrToUlong(b);
}

Referenced by PropertyStorage_CreateDictionaries().

PropertyStorage_PropertiesWriter()

static BOOL PropertyStorage_PropertiesWriter ( const void *  key, const void *  value, void *  extra, void *  closure  )

static

Definition at line 1868 of file stg_prop.c.

{
    PropertyStorage_impl *This = extra;
    struct PropertyClosure *c = closure;
 
    assert(key);
    assert(value);
    assert(extra);
    assert(closure);
    c->hr = PropertyStorage_WritePropertyToStream(This, c->propNum++,
                                                  PtrToUlong(key), value, c->sectionOffset);
    return SUCCEEDED(c->hr);
}

Referenced by PropertyStorage_WritePropertiesToStream().

PropertyStorage_PropertyDestroy()

static void PropertyStorage_PropertyDestroy ( void *  k, void *  d, void *  extra  )

static

Definition at line 965 of file stg_prop.c.

{
    PropVariantClear(d);
    HeapFree(GetProcessHeap(), 0, d);
}

Referenced by PropertyStorage_CreateDictionaries().

PropertyStorage_PropNameCompare()

static int PropertyStorage_PropNameCompare ( const void *  a, const void *  b, void *  extra  )

static

Definition at line 930 of file stg_prop.c.

{
    PropertyStorage_impl *This = extra;
 
    if (This->codePage == CP_UNICODE)
    {
        TRACE("(%s, %s)\n", debugstr_w(a), debugstr_w(b));
        if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
            return wcscmp(a, b);
        else
            return lstrcmpiW(a, b);
    }
    else
    {
        TRACE("(%s, %s)\n", debugstr_a(a), debugstr_a(b));
        if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
            return lstrcmpA(a, b);
        else
            return lstrcmpiA(a, b);
    }
}

Referenced by PropertyStorage_CreateDictionaries().

PropertyStorage_PropNameDestroy()

static void PropertyStorage_PropNameDestroy ( void *  k, void *  d, void *  extra  )

static

Definition at line 953 of file stg_prop.c.

{
    CoTaskMemFree(k);
}

Referenced by PropertyStorage_CreateDictionaries().

PropertyStorage_PropVariantCopy()

static HRESULT PropertyStorage_PropVariantCopy ( PROPVARIANT *  prop, const PROPVARIANT *  propvar, LCID  targetCP, LCID  srcCP  )

static

Definition at line 438 of file stg_prop.c.

{
    HRESULT hr = S_OK;
 
    assert(prop);
    assert(propvar);
    if (propvar->vt == VT_LPSTR)
    {
        hr = PropertyStorage_StringCopy(propvar->u.pszVal, srcCP,
         &prop->u.pszVal, targetCP);
        if (SUCCEEDED(hr))
            prop->vt = VT_LPSTR;
    }
    else
        PropVariantCopy(prop, propvar);
    return hr;
}

Referenced by IPropertyStorage_fnReadMultiple(), and PropertyStorage_StorePropWithId().

PropertyStorage_ReadDictionary()

static HRESULT PropertyStorage_ReadDictionary ( PropertyStorage_impl *  This, BYTE *  ptr  )

static

Definition at line 994 of file stg_prop.c.

{
    DWORD numEntries, i;
    HRESULT hr = S_OK;
 
    assert(This->name_to_propid);
    assert(This->propid_to_name);
 
    StorageUtl_ReadDWord(ptr, 0, &numEntries);
    TRACE("Reading %d entries:\n", numEntries);
    ptr += sizeof(DWORD);
    for (i = 0; SUCCEEDED(hr) && i < numEntries; i++)
    {
        PROPID propid;
        DWORD cbEntry;
 
        StorageUtl_ReadDWord(ptr, 0, &propid);
        ptr += sizeof(PROPID);
        StorageUtl_ReadDWord(ptr, 0, &cbEntry);
        ptr += sizeof(DWORD);
        TRACE("Reading entry with ID 0x%08x, %d bytes\n", propid, cbEntry);
        /* Make sure the source string is NULL-terminated */
        if (This->codePage != CP_UNICODE)
            ptr[cbEntry - 1] = '\0';
        else
            ((LPWSTR)ptr)[cbEntry - 1] = 0;
        hr = PropertyStorage_StoreNameWithId(This, (char*)ptr, This->codePage, propid);
        if (This->codePage == CP_UNICODE)
        {
            /* cbEntry is the number of characters */
            cbEntry *= 2;
 
            /* Unicode entries are padded to DWORD boundaries */
            if (cbEntry % sizeof(DWORD))
                ptr += sizeof(DWORD) - (cbEntry % sizeof(DWORD));
        }
        ptr += cbEntry;
    }
    return hr;
}

Referenced by PropertyStorage_ReadFromStream().

PropertyStorage_ReadFmtIdOffsetFromStream()

static HRESULT PropertyStorage_ReadFmtIdOffsetFromStream ( IStream *  stm, FORMATIDOFFSET *  fmt  )

static

Definition at line 1280 of file stg_prop.c.

{
    BYTE buf[sizeof(FORMATIDOFFSET)];
    ULONG count = 0;
    HRESULT hr;
 
    assert(stm);
    assert(fmt);
    hr = IStream_Read(stm, buf, sizeof(buf), &count);
    if (SUCCEEDED(hr))
    {
        if (count != sizeof(buf))
        {
            WARN("read only %d\n", count);
            hr = STG_E_INVALIDHEADER;
        }
        else
        {
            StorageUtl_ReadGUID(buf, offsetof(FORMATIDOFFSET, fmtid),
             &fmt->fmtid);
            StorageUtl_ReadDWord(buf, offsetof(FORMATIDOFFSET, dwOffset),
             &fmt->dwOffset);
        }
    }
    TRACE("returning 0x%08x\n", hr);
    return hr;
}

Referenced by PropertyStorage_ReadFromStream().

PropertyStorage_ReadFromStream()

static HRESULT PropertyStorage_ReadFromStream ( PropertyStorage_impl *  This )

static

Definition at line 1338 of file stg_prop.c.

{
    PROPERTYSETHEADER hdr;
    FORMATIDOFFSET fmtOffset;
    PROPERTYSECTIONHEADER sectionHdr;
    LARGE_INTEGER seek;
    ULONG i;
    STATSTG stat;
    HRESULT hr;
    BYTE *buf = NULL;
    ULONG count = 0;
    DWORD dictOffset = 0;
 
    This->dirty = FALSE;
    This->highestProp = 0;
    hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
    if (FAILED(hr))
        goto end;
    if (stat.cbSize.u.HighPart)
    {
        WARN("stream too big\n");
        /* maximum size varies, but it can't be this big */
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    if (stat.cbSize.u.LowPart == 0)
    {
        /* empty stream is okay */
        hr = S_OK;
        goto end;
    }
    else if (stat.cbSize.u.LowPart < sizeof(PROPERTYSETHEADER) +
     sizeof(FORMATIDOFFSET))
    {
        WARN("stream too small\n");
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    seek.QuadPart = 0;
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    hr = PropertyStorage_ReadHeaderFromStream(This->stm, &hdr);
    /* I've only seen reserved == 1, but the article says I shouldn't disallow
     * higher values.
     */
    if (hdr.wByteOrder != PROPSETHDR_BYTEORDER_MAGIC || hdr.reserved < 1)
    {
        WARN("bad magic in prop set header\n");
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    if (hdr.wFormat != 0 && hdr.wFormat != 1)
    {
        WARN("bad format version %d\n", hdr.wFormat);
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    This->format = hdr.wFormat;
    This->clsid = hdr.clsid;
    This->originatorOS = hdr.dwOSVer;
    if (PROPSETHDR_OSVER_KIND(hdr.dwOSVer) == PROPSETHDR_OSVER_KIND_MAC)
        WARN("File comes from a Mac, strings will probably be screwed up\n");
    hr = PropertyStorage_ReadFmtIdOffsetFromStream(This->stm, &fmtOffset);
    if (FAILED(hr))
        goto end;
    if (fmtOffset.dwOffset > stat.cbSize.u.LowPart)
    {
        WARN("invalid offset %d (stream length is %d)\n", fmtOffset.dwOffset,
         stat.cbSize.u.LowPart);
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    /* wackiness alert: if the format ID is FMTID_DocSummaryInformation, there
     * follows not one, but two sections.  The first contains the standard properties
     * for the document summary information, and the second consists of user-defined
     * properties.  This is the only case in which multiple sections are
     * allowed.
     * Reading the second stream isn't implemented yet.
     */
    hr = PropertyStorage_ReadSectionHeaderFromStream(This->stm, &sectionHdr);
    if (FAILED(hr))
        goto end;
    /* The section size includes the section header, so check it */
    if (sectionHdr.cbSection < sizeof(PROPERTYSECTIONHEADER))
    {
        WARN("section header too small, got %d\n", sectionHdr.cbSection);
        hr = STG_E_INVALIDHEADER;
        goto end;
    }
    buf = HeapAlloc(GetProcessHeap(), 0, sectionHdr.cbSection -
     sizeof(PROPERTYSECTIONHEADER));
    if (!buf)
    {
        hr = STG_E_INSUFFICIENTMEMORY;
        goto end;
    }
    hr = IStream_Read(This->stm, buf, sectionHdr.cbSection -
     sizeof(PROPERTYSECTIONHEADER), &count);
    if (FAILED(hr))
        goto end;
    TRACE("Reading %d properties:\n", sectionHdr.cProperties);
    for (i = 0; SUCCEEDED(hr) && i < sectionHdr.cProperties; i++)
    {
        PROPERTYIDOFFSET *idOffset = (PROPERTYIDOFFSET *)(buf +
         i * sizeof(PROPERTYIDOFFSET));
 
        if (idOffset->dwOffset < sizeof(PROPERTYSECTIONHEADER) ||
         idOffset->dwOffset > sectionHdr.cbSection - sizeof(DWORD))
            hr = STG_E_INVALIDPOINTER;
        else
        {
            if (idOffset->propid >= PID_FIRST_USABLE &&
             idOffset->propid < PID_MIN_READONLY && idOffset->propid >
             This->highestProp)
                This->highestProp = idOffset->propid;
            if (idOffset->propid == PID_DICTIONARY)
            {
                /* Don't read the dictionary yet, its entries depend on the
                 * code page.  Just store the offset so we know to read it
                 * later.
                 */
                dictOffset = idOffset->dwOffset;
                TRACE("Dictionary offset is %d\n", dictOffset);
            }
            else
            {
                PROPVARIANT prop;
 
                PropVariantInit(&prop);
                if (SUCCEEDED(PropertyStorage_ReadProperty(&prop,
                 buf + idOffset->dwOffset - sizeof(PROPERTYSECTIONHEADER),
                 This->codePage, Allocate_CoTaskMemAlloc, NULL)))
                {
                    TRACE("Read property with ID 0x%08x, type %d\n",
                     idOffset->propid, prop.vt);
                    switch(idOffset->propid)
                    {
                    case PID_CODEPAGE:
                        if (prop.vt == VT_I2)
                            This->codePage = (UINT)prop.u.iVal;
                        break;
                    case PID_LOCALE:
                        if (prop.vt == VT_I4)
                            This->locale = (LCID)prop.u.lVal;
                        break;
                    case PID_BEHAVIOR:
                        if (prop.vt == VT_I4 && prop.u.lVal)
                            This->grfFlags |= PROPSETFLAG_CASE_SENSITIVE;
                        /* The format should already be 1, but just in case */
                        This->format = 1;
                        break;
                    default:
                        hr = PropertyStorage_StorePropWithId(This,
                         idOffset->propid, &prop, This->codePage);
                    }
                }
                PropVariantClear(&prop);
            }
        }
    }
    if (!This->codePage)
    {
        /* default to Unicode unless told not to, as specified on msdn */
        if (This->grfFlags & PROPSETFLAG_ANSI)
            This->codePage = GetACP();
        else
            This->codePage = CP_UNICODE;
    }
    if (!This->locale)
        This->locale = LOCALE_SYSTEM_DEFAULT;
    TRACE("Code page is %d, locale is %d\n", This->codePage, This->locale);
    if (dictOffset)
        hr = PropertyStorage_ReadDictionary(This,
         buf + dictOffset - sizeof(PROPERTYSECTIONHEADER));
 
end:
    HeapFree(GetProcessHeap(), 0, buf);
    if (FAILED(hr))
    {
        dictionary_destroy(This->name_to_propid);
        This->name_to_propid = NULL;
        dictionary_destroy(This->propid_to_name);
        This->propid_to_name = NULL;
        dictionary_destroy(This->propid_to_prop);
        This->propid_to_prop = NULL;
    }
    return hr;
}

Referenced by IPropertyStorage_fnRevert(), and PropertyStorage_ConstructFromStream().

PropertyStorage_ReadHeaderFromStream()

static HRESULT PropertyStorage_ReadHeaderFromStream ( IStream *  stm, PROPERTYSETHEADER *  hdr  )

static

Definition at line 1245 of file stg_prop.c.

{
    BYTE buf[sizeof(PROPERTYSETHEADER)];
    ULONG count = 0;
    HRESULT hr;
 
    assert(stm);
    assert(hdr);
    hr = IStream_Read(stm, buf, sizeof(buf), &count);
    if (SUCCEEDED(hr))
    {
        if (count != sizeof(buf))
        {
            WARN("read only %d\n", count);
            hr = STG_E_INVALIDHEADER;
        }
        else
        {
            StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wByteOrder),
             &hdr->wByteOrder);
            StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wFormat),
             &hdr->wFormat);
            StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, dwOSVer),
             &hdr->dwOSVer);
            StorageUtl_ReadGUID(buf, offsetof(PROPERTYSETHEADER, clsid),
             &hdr->clsid);
            StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, reserved),
             &hdr->reserved);
        }
    }
    TRACE("returning 0x%08x\n", hr);
    return hr;
}

Referenced by PropertyStorage_ReadFromStream().

PropertyStorage_ReadProperty()

static HRESULT PropertyStorage_ReadProperty ( PROPVARIANT *  prop, const BYTE *  data, UINT  codepage, void *  __thiscall_wrapper *allocate)(void *this, ULONG size, void *  allocate_data  )

static

Definition at line 1050 of file stg_prop.c.

{
    HRESULT hr = S_OK;
    DWORD vt;
 
    assert(prop);
    assert(data);
    StorageUtl_ReadDWord(data, 0, &vt);
    data += sizeof(DWORD);
    prop->vt = vt;
    switch (prop->vt)
    {
    case VT_EMPTY:
    case VT_NULL:
        break;
    case VT_I1:
        prop->u.cVal = *(const char *)data;
        TRACE("Read char 0x%x ('%c')\n", prop->u.cVal, prop->u.cVal);
        break;
    case VT_UI1:
        prop->u.bVal = *data;
        TRACE("Read byte 0x%x\n", prop->u.bVal);
        break;
    case VT_BOOL:
        StorageUtl_ReadWord(data, 0, (WORD*)&prop->u.boolVal);
        TRACE("Read bool %d\n", prop->u.boolVal);
        break;
    case VT_I2:
        StorageUtl_ReadWord(data, 0, (WORD*)&prop->u.iVal);
        TRACE("Read short %d\n", prop->u.iVal);
        break;
    case VT_UI2:
        StorageUtl_ReadWord(data, 0, &prop->u.uiVal);
        TRACE("Read ushort %d\n", prop->u.uiVal);
        break;
    case VT_INT:
    case VT_I4:
        StorageUtl_ReadDWord(data, 0, (DWORD*)&prop->u.lVal);
        TRACE("Read long %d\n", prop->u.lVal);
        break;
    case VT_UINT:
    case VT_UI4:
        StorageUtl_ReadDWord(data, 0, &prop->u.ulVal);
        TRACE("Read ulong %d\n", prop->u.ulVal);
        break;
    case VT_I8:
        StorageUtl_ReadULargeInteger(data, 0, (ULARGE_INTEGER *)&prop->u.hVal);
        TRACE("Read long long %s\n", wine_dbgstr_longlong(prop->u.hVal.QuadPart));
        break;
    case VT_UI8:
        StorageUtl_ReadULargeInteger(data, 0, &prop->u.uhVal);
        TRACE("Read ulong long %s\n", wine_dbgstr_longlong(prop->u.uhVal.QuadPart));
        break;
    case VT_R8:
        memcpy(&prop->u.dblVal, data, sizeof(double));
        TRACE("Read double %f\n", prop->u.dblVal);
        break;
    case VT_LPSTR:
    {
        DWORD count;
       
        StorageUtl_ReadDWord(data, 0, &count);
        if (codepage == CP_UNICODE && count % 2)
        {
            WARN("Unicode string has odd number of bytes\n");
            hr = STG_E_INVALIDHEADER;
        }
        else
        {
            prop->u.pszVal = allocate(allocate_data, count);
            if (prop->u.pszVal)
            {
                memcpy(prop->u.pszVal, data + sizeof(DWORD), count);
                /* This is stored in the code page specified in codepage.
                 * Don't convert it, the caller will just store it as-is.
                 */
                if (codepage == CP_UNICODE)
                {
                    /* Make sure it's NULL-terminated */
                    prop->u.pszVal[count / sizeof(WCHAR) - 1] = '\0';
                    TRACE("Read string value %s\n",
                     debugstr_w(prop->u.pwszVal));
                }
                else
                {
                    /* Make sure it's NULL-terminated */
                    prop->u.pszVal[count - 1] = '\0';
                    TRACE("Read string value %s\n", debugstr_a(prop->u.pszVal));
                }
            }
            else
                hr = STG_E_INSUFFICIENTMEMORY;
        }
        break;
    }
    case VT_BSTR:
    {
        DWORD count, wcount;
 
        StorageUtl_ReadDWord(data, 0, &count);
        if (codepage == CP_UNICODE && count % 2)
        {
            WARN("Unicode string has odd number of bytes\n");
            hr = STG_E_INVALIDHEADER;
        }
        else
        {
            if (codepage == CP_UNICODE)
                wcount = count / 2;
            else
                wcount = MultiByteToWideChar(codepage, 0, (LPCSTR)(data + sizeof(DWORD)), count, NULL, 0);
 
            prop->u.bstrVal = SysAllocStringLen(NULL, wcount); /* FIXME: use allocator? */
 
            if (prop->u.bstrVal)
            {
                if (codepage == CP_UNICODE)
                    memcpy(prop->u.bstrVal, data + sizeof(DWORD), count);
                else
                    MultiByteToWideChar(codepage, 0, (LPCSTR)(data + sizeof(DWORD)), count, prop->u.bstrVal, wcount);
 
                prop->u.bstrVal[wcount - 1] = '\0';
                TRACE("Read string value %s\n", debugstr_w(prop->u.bstrVal));
            }
            else
                hr = STG_E_INSUFFICIENTMEMORY;
        }
        break;
    }
    case VT_BLOB:
    {
        DWORD count;
 
        StorageUtl_ReadDWord(data, 0, &count);
        prop->u.blob.cbSize = count;
        prop->u.blob.pBlobData = allocate(allocate_data, count);
        if (prop->u.blob.pBlobData)
        {
            memcpy(prop->u.blob.pBlobData, data + sizeof(DWORD), count);
            TRACE("Read blob value of size %d\n", count);
        }
        else
            hr = STG_E_INSUFFICIENTMEMORY;
        break;
    }
    case VT_LPWSTR:
    {
        DWORD count;
 
        StorageUtl_ReadDWord(data, 0, &count);
        prop->u.pwszVal = allocate(allocate_data, count * sizeof(WCHAR));
        if (prop->u.pwszVal)
        {
            memcpy(prop->u.pwszVal, data + sizeof(DWORD),
             count * sizeof(WCHAR));
            /* make sure string is NULL-terminated */
            prop->u.pwszVal[count - 1] = '\0';
            PropertyStorage_ByteSwapString(prop->u.pwszVal, count);
            TRACE("Read string value %s\n", debugstr_w(prop->u.pwszVal));
        }
        else
            hr = STG_E_INSUFFICIENTMEMORY;
        break;
    }
    case VT_FILETIME:
        StorageUtl_ReadULargeInteger(data, 0,
         (ULARGE_INTEGER *)&prop->u.filetime);
        break;
    case VT_CF:
        {
            DWORD len = 0, tag = 0;
 
            StorageUtl_ReadDWord(data, 0, &len);
            StorageUtl_ReadDWord(data, 4, &tag);
            if (len > 8)
            {
                len -= 8;
                prop->u.pclipdata = allocate(allocate_data, sizeof (CLIPDATA));
                prop->u.pclipdata->cbSize = len;
                prop->u.pclipdata->ulClipFmt = tag;
                prop->u.pclipdata->pClipData = allocate(allocate_data, len - sizeof(prop->u.pclipdata->ulClipFmt));
                memcpy(prop->u.pclipdata->pClipData, data+8, len - sizeof(prop->u.pclipdata->ulClipFmt));
            }
            else
                hr = STG_E_INVALIDPARAMETER;
        }
        break;
    default:
        FIXME("unsupported type %d\n", prop->vt);
        hr = STG_E_INVALIDPARAMETER;
    }
    return hr;
}

Referenced by PropertyStorage_ReadFromStream(), and StgConvertPropertyToVariant().

PropertyStorage_ReadSectionHeaderFromStream()

static HRESULT PropertyStorage_ReadSectionHeaderFromStream ( IStream *  stm, PROPERTYSECTIONHEADER *  hdr  )

static

Definition at line 1309 of file stg_prop.c.

{
    BYTE buf[sizeof(PROPERTYSECTIONHEADER)];
    ULONG count = 0;
    HRESULT hr;
 
    assert(stm);
    assert(hdr);
    hr = IStream_Read(stm, buf, sizeof(buf), &count);
    if (SUCCEEDED(hr))
    {
        if (count != sizeof(buf))
        {
            WARN("read only %d\n", count);
            hr = STG_E_INVALIDHEADER;
        }
        else
        {
            StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
             cbSection), &hdr->cbSection);
            StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
             cProperties), &hdr->cProperties);
        }
    }
    TRACE("returning 0x%08x\n", hr);
    return hr;
}

Referenced by PropertyStorage_ReadFromStream().

PropertyStorage_StoreNameWithId()

static HRESULT PropertyStorage_StoreNameWithId ( PropertyStorage_impl *  This, LPCSTR  srcName, LCID  cp, PROPID  id  )

static

Definition at line 519 of file stg_prop.c.

{
    LPSTR name;
    HRESULT hr;
 
    assert(srcName);
 
    hr = PropertyStorage_StringCopy(srcName, cp, &name, This->codePage);
    if (SUCCEEDED(hr))
    {
        if (This->codePage == CP_UNICODE)
        {
            if (lstrlenW((LPWSTR)name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
                This->format = 1;
        }
        else
        {
            if (strlen(name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
                This->format = 1;
        }
        TRACE("Adding prop name %s, propid %d\n",
         This->codePage == CP_UNICODE ? debugstr_w((LPCWSTR)name) :
         debugstr_a(name), id);
        dictionary_insert(This->name_to_propid, name, UlongToPtr(id));
        dictionary_insert(This->propid_to_name, UlongToPtr(id), name);
    }
    return hr;
}

Referenced by IPropertyStorage_fnWriteMultiple(), IPropertyStorage_fnWritePropertyNames(), and PropertyStorage_ReadDictionary().

PropertyStorage_StorePropWithId()

static HRESULT PropertyStorage_StorePropWithId ( PropertyStorage_impl *  This, PROPID  propid, const PROPVARIANT *  propvar, LCID  lcid  )

static

Definition at line 464 of file stg_prop.c.

{
    HRESULT hr = S_OK;
    PROPVARIANT *prop = PropertyStorage_FindProperty(This, propid);
 
    assert(propvar);
    if (propvar->vt & VT_BYREF || propvar->vt & VT_ARRAY)
        This->format = 1;
    switch (propvar->vt)
    {
    case VT_DECIMAL:
    case VT_I1:
    case VT_INT:
    case VT_UINT:
    case VT_VECTOR|VT_I1:
        This->format = 1;
    }
    TRACE("Setting 0x%08x to type %d\n", propid, propvar->vt);
    if (prop)
    {
        PropVariantClear(prop);
        hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
         lcid);
    }
    else
    {
        prop = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
         sizeof(PROPVARIANT));
        if (prop)
        {
            hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
             lcid);
            if (SUCCEEDED(hr))
            {
                dictionary_insert(This->propid_to_prop, UlongToPtr(propid), prop);
                if (propid > This->highestProp)
                    This->highestProp = propid;
            }
            else
                HeapFree(GetProcessHeap(), 0, prop);
        }
        else
            hr = STG_E_INSUFFICIENTMEMORY;
    }
    return hr;
}

Referenced by IPropertyStorage_fnWriteMultiple(), and PropertyStorage_ReadFromStream().

PropertyStorage_StringCopy()

static HRESULT PropertyStorage_StringCopy ( LPCSTR  src, LCID  srcCP, LPSTR *  dst, LCID  targetCP  )

static

Definition at line 354 of file stg_prop.c.

{
    HRESULT hr = S_OK;
    int len;
 
    TRACE("%s, %p, %d, %d\n",
     srcCP == CP_UNICODE ? debugstr_w((LPCWSTR)src) : debugstr_a(src), dst,
     dstCP, srcCP);
    assert(src);
    assert(dst);
    *dst = NULL;
    if (dstCP == srcCP)
    {
        size_t len;
 
        if (dstCP == CP_UNICODE)
            len = (lstrlenW((LPCWSTR)src) + 1) * sizeof(WCHAR);
        else
            len = strlen(src) + 1;
        *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
        if (!*dst)
            hr = STG_E_INSUFFICIENTMEMORY;
        else
            memcpy(*dst, src, len);
    }
    else
    {
        if (dstCP == CP_UNICODE)
        {
            len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
            *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
            if (!*dst)
                hr = STG_E_INSUFFICIENTMEMORY;
            else
                MultiByteToWideChar(srcCP, 0, src, -1, (LPWSTR)*dst, len);
        }
        else
        {
            LPCWSTR wideStr = NULL;
            LPWSTR wideStr_tmp = NULL;
 
            if (srcCP == CP_UNICODE)
                wideStr = (LPCWSTR)src;
            else
            {
                len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
                wideStr_tmp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
                if (wideStr_tmp)
                {
                    MultiByteToWideChar(srcCP, 0, src, -1, wideStr_tmp, len);
                    wideStr = wideStr_tmp;
                }
                else
                    hr = STG_E_INSUFFICIENTMEMORY;
            }
            if (SUCCEEDED(hr))
            {
                len = WideCharToMultiByte(dstCP, 0, wideStr, -1, NULL, 0,
                 NULL, NULL);
                *dst = CoTaskMemAlloc(len);
                if (!*dst)
                    hr = STG_E_INSUFFICIENTMEMORY;
                else
                {
                    BOOL defCharUsed = FALSE;
 
                    if (WideCharToMultiByte(dstCP, 0, wideStr, -1, *dst, len,
                     NULL, &defCharUsed) == 0 || defCharUsed)
                    {
                        CoTaskMemFree(*dst);
                        *dst = NULL;
                        hr = HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION);
                    }
                }
            }
            HeapFree(GetProcessHeap(), 0, wideStr_tmp);
        }
    }
    TRACE("returning 0x%08x (%s)\n", hr,
     dstCP == CP_UNICODE ? debugstr_w((LPCWSTR)*dst) : debugstr_a(*dst));
    return hr;
}

Referenced by PropertyStorage_FindPropertyByName(), PropertyStorage_PropVariantCopy(), and PropertyStorage_StoreNameWithId().

PropertyStorage_WriteDictionaryToStream()

static HRESULT PropertyStorage_WriteDictionaryToStream ( PropertyStorage_impl *  This, DWORD *  sectionOffset  )

static

Definition at line 1654 of file stg_prop.c.

{
    HRESULT hr;
    LARGE_INTEGER seek;
    PROPERTYIDOFFSET propIdOffset;
    ULONG count;
    DWORD dwTemp;
    struct DictionaryClosure closure;
 
    assert(sectionOffset);
 
    /* The dictionary's always the first property written, so seek to its
     * spot.
     */
    seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER);
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    PropertyStorage_MakePropertyIdOffset(PID_DICTIONARY, *sectionOffset,
     &propIdOffset);
    hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
    if (FAILED(hr))
        goto end;
 
    seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0,
     dictionary_num_entries(This->name_to_propid));
    hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
    if (FAILED(hr))
        goto end;
    *sectionOffset += sizeof(dwTemp);
 
    closure.hr = S_OK;
    closure.bytesWritten = 0;
    dictionary_enumerate(This->name_to_propid, PropertyStorage_DictionaryWriter,
     &closure);
    hr = closure.hr;
    if (FAILED(hr))
        goto end;
    *sectionOffset += closure.bytesWritten;
    if (closure.bytesWritten % sizeof(DWORD))
    {
        DWORD padding = sizeof(DWORD) - closure.bytesWritten % sizeof(DWORD);
        TRACE("adding %d bytes of padding\n", padding);
        *sectionOffset += padding;
    }
 
end:
    return hr;
}

Referenced by PropertyStorage_WriteToStream().

PropertyStorage_WriteHeadersToStream()

static HRESULT PropertyStorage_WriteHeadersToStream ( PropertyStorage_impl *  This )

static

Definition at line 1897 of file stg_prop.c.

{
    HRESULT hr;
    ULONG count = 0;
    LARGE_INTEGER seek = { {0} };
    PROPERTYSETHEADER hdr;
    FORMATIDOFFSET fmtOffset;
 
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    PropertyStorage_MakeHeader(This, &hdr);
    hr = IStream_Write(This->stm, &hdr, sizeof(hdr), &count);
    if (FAILED(hr))
        goto end;
    if (count != sizeof(hdr))
    {
        hr = STG_E_WRITEFAULT;
        goto end;
    }
 
    PropertyStorage_MakeFmtIdOffset(This, &fmtOffset);
    hr = IStream_Write(This->stm, &fmtOffset, sizeof(fmtOffset), &count);
    if (FAILED(hr))
        goto end;
    if (count != sizeof(fmtOffset))
    {
        hr = STG_E_WRITEFAULT;
        goto end;
    }
    hr = S_OK;
 
end:
    return hr;
}

Referenced by PropertyStorage_WriteToStream().

PropertyStorage_WritePropertiesToStream()

static HRESULT PropertyStorage_WritePropertiesToStream ( PropertyStorage_impl *  This, DWORD  startingPropNum, DWORD *  sectionOffset  )

static

Definition at line 1883 of file stg_prop.c.

{
    struct PropertyClosure closure;
 
    assert(sectionOffset);
    closure.hr = S_OK;
    closure.propNum = startingPropNum;
    closure.sectionOffset = sectionOffset;
    dictionary_enumerate(This->propid_to_prop, PropertyStorage_PropertiesWriter,
     &closure);
    return closure.hr;
}

Referenced by PropertyStorage_WriteToStream().

PropertyStorage_WritePropertyToStream()

static HRESULT PropertyStorage_WritePropertyToStream ( PropertyStorage_impl *  This, DWORD  propNum, DWORD  propid, const PROPVARIANT *  var, DWORD *  sectionOffset  )

static

Definition at line 1709 of file stg_prop.c.

{
    HRESULT hr;
    LARGE_INTEGER seek;
    PROPERTYIDOFFSET propIdOffset;
    ULONG count;
    DWORD dwType, bytesWritten;
 
    assert(var);
    assert(sectionOffset);
 
    TRACE("%p, %d, 0x%08x, (%d), (%d)\n", This, propNum, propid, var->vt,
     *sectionOffset);
 
    seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER) +
     propNum * sizeof(PROPERTYIDOFFSET);
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    PropertyStorage_MakePropertyIdOffset(propid, *sectionOffset, &propIdOffset);
    hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
    if (FAILED(hr))
        goto end;
 
    seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    StorageUtl_WriteDWord((LPBYTE)&dwType, 0, var->vt);
    hr = IStream_Write(This->stm, &dwType, sizeof(dwType), &count);
    if (FAILED(hr))
        goto end;
    *sectionOffset += sizeof(dwType);
 
    switch (var->vt)
    {
    case VT_EMPTY:
    case VT_NULL:
        bytesWritten = 0;
        break;
    case VT_I1:
    case VT_UI1:
        hr = IStream_Write(This->stm, &var->u.cVal, sizeof(var->u.cVal),
         &count);
        bytesWritten = count;
        break;
    case VT_I2:
    case VT_UI2:
    {
        WORD wTemp;
 
        StorageUtl_WriteWord((LPBYTE)&wTemp, 0, var->u.iVal);
        hr = IStream_Write(This->stm, &wTemp, sizeof(wTemp), &count);
        bytesWritten = count;
        break;
    }
    case VT_I4:
    case VT_UI4:
    {
        DWORD dwTemp;
 
        StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, var->u.lVal);
        hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
        bytesWritten = count;
        break;
    }
    case VT_LPSTR:
    {
        DWORD len, dwTemp;
 
        if (This->codePage == CP_UNICODE)
            len = (lstrlenW(var->u.pwszVal) + 1) * sizeof(WCHAR);
        else
            len = lstrlenA(var->u.pszVal) + 1;
        StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, len);
        hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
        if (FAILED(hr))
            goto end;
        hr = IStream_Write(This->stm, var->u.pszVal, len, &count);
        bytesWritten = count + sizeof(DWORD);
        break;
    }
    case VT_LPWSTR:
    {
        DWORD len = lstrlenW(var->u.pwszVal) + 1, dwTemp;
 
        StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, len);
        hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
        if (FAILED(hr))
            goto end;
        hr = IStream_Write(This->stm, var->u.pwszVal, len * sizeof(WCHAR),
         &count);
        bytesWritten = count + sizeof(DWORD);
        break;
    }
    case VT_FILETIME:
    {
        FILETIME temp;
 
        StorageUtl_WriteULargeInteger((BYTE *)&temp, 0,
         (const ULARGE_INTEGER *)&var->u.filetime);
        hr = IStream_Write(This->stm, &temp, sizeof(FILETIME), &count);
        bytesWritten = count;
        break;
    }
    case VT_CF:
    {
        DWORD cf_hdr[2], len;
 
        len = var->u.pclipdata->cbSize;
        StorageUtl_WriteDWord((LPBYTE)&cf_hdr[0], 0, len + 8);
        StorageUtl_WriteDWord((LPBYTE)&cf_hdr[1], 0, var->u.pclipdata->ulClipFmt);
        hr = IStream_Write(This->stm, cf_hdr, sizeof(cf_hdr), &count);
        if (FAILED(hr))
            goto end;
        hr = IStream_Write(This->stm, var->u.pclipdata->pClipData,
                           len - sizeof(var->u.pclipdata->ulClipFmt), &count);
        if (FAILED(hr))
            goto end;
        bytesWritten = count + sizeof cf_hdr;
        break;
    }
    case VT_CLSID:
    {
        CLSID temp;
 
        StorageUtl_WriteGUID((BYTE *)&temp, 0, var->u.puuid);
        hr = IStream_Write(This->stm, &temp, sizeof(temp), &count);
        bytesWritten = count;
        break;
    }
    default:
        FIXME("unsupported type: %d\n", var->vt);
        return STG_E_INVALIDPARAMETER;
    }
 
    if (SUCCEEDED(hr))
    {
        *sectionOffset += bytesWritten;
        if (bytesWritten % sizeof(DWORD))
        {
            DWORD padding = sizeof(DWORD) - bytesWritten % sizeof(DWORD);
            TRACE("adding %d bytes of padding\n", padding);
            *sectionOffset += padding;
        }
    }
 
end:
    return hr;
}

Referenced by PropertyStorage_PropertiesWriter(), and PropertyStorage_WriteToStream().

PropertyStorage_WriteToStream()

static HRESULT PropertyStorage_WriteToStream ( PropertyStorage_impl *  This )

static

Definition at line 1933 of file stg_prop.c.

{
    PROPERTYSECTIONHEADER sectionHdr;
    HRESULT hr;
    ULONG count;
    LARGE_INTEGER seek;
    DWORD numProps, prop, sectionOffset, dwTemp;
    PROPVARIANT var;
 
    PropertyStorage_WriteHeadersToStream(This);
 
    /* Count properties.  Always at least one property, the code page */
    numProps = 1;
    if (dictionary_num_entries(This->name_to_propid))
        numProps++;
    if (This->locale != LOCALE_SYSTEM_DEFAULT)
        numProps++;
    if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
        numProps++;
    numProps += dictionary_num_entries(This->propid_to_prop);
 
    /* Write section header with 0 bytes right now, I'll adjust it after
     * writing properties.
     */
    PropertyStorage_MakeSectionHdr(0, numProps, &sectionHdr);
    seek.QuadPart = SECTIONHEADER_OFFSET;
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    hr = IStream_Write(This->stm, &sectionHdr, sizeof(sectionHdr), &count);
    if (FAILED(hr))
        goto end;
 
    prop = 0;
    sectionOffset = sizeof(PROPERTYSECTIONHEADER) +
     numProps * sizeof(PROPERTYIDOFFSET);
 
    if (dictionary_num_entries(This->name_to_propid))
    {
        prop++;
        hr = PropertyStorage_WriteDictionaryToStream(This, &sectionOffset);
        if (FAILED(hr))
            goto end;
    }
 
    PropVariantInit(&var);
 
    var.vt = VT_I2;
    var.u.iVal = This->codePage;
    hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_CODEPAGE,
     &var, &sectionOffset);
    if (FAILED(hr))
        goto end;
 
    if (This->locale != LOCALE_SYSTEM_DEFAULT)
    {
        var.vt = VT_I4;
        var.u.lVal = This->locale;
        hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_LOCALE,
         &var, &sectionOffset);
        if (FAILED(hr))
            goto end;
    }
 
    if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
    {
        var.vt = VT_I4;
        var.u.lVal = 1;
        hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_BEHAVIOR,
         &var, &sectionOffset);
        if (FAILED(hr))
            goto end;
    }
 
    hr = PropertyStorage_WritePropertiesToStream(This, prop, &sectionOffset);
    if (FAILED(hr))
        goto end;
 
    /* Now write the byte count of the section */
    seek.QuadPart = SECTIONHEADER_OFFSET;
    hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr))
        goto end;
    StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, sectionOffset);
    hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
 
end:
    return hr;
}

Referenced by IPropertyStorage_fnCommit().

PropStgNameToFmtId()

HRESULT WINAPI PropStgNameToFmtId	(	const LPOLESTR	str,
		FMTID *	rfmtid
	)

Definition at line 2700 of file stg_prop.c.

{
    HRESULT hr = STG_E_INVALIDNAME;
 
    TRACE("%s, %p\n", debugstr_w(str), rfmtid);
 
    if (!rfmtid) return E_INVALIDARG;
    if (!str) return STG_E_INVALIDNAME;
 
    if (!lstrcmpiW(str, szDocSummaryInfo))
    {
        *rfmtid = FMTID_DocSummaryInformation;
        hr = S_OK;
    }
    else if (!lstrcmpiW(str, szSummaryInfo))
    {
        *rfmtid = FMTID_SummaryInformation;
        hr = S_OK;
    }
    else
    {
        ULONG bits;
        BYTE *fmtptr = (BYTE *)rfmtid - 1;
        const WCHAR *pstr = str;
 
        memset(rfmtid, 0, sizeof(*rfmtid));
        for (bits = 0; bits < sizeof(FMTID) * BITS_PER_BYTE;
         bits += BITS_IN_CHARMASK)
        {
            ULONG bitsUsed = bits % BITS_PER_BYTE, bitsStored;
            WCHAR wc;
 
            if (bitsUsed == 0)
                fmtptr++;
            wc = *++pstr - 'A';
            if (wc > NUM_ALPHA_CHARS)
            {
                wc += 'A' - 'a';
                if (wc > NUM_ALPHA_CHARS)
                {
                    wc += 'a' - '0' + NUM_ALPHA_CHARS;
                    if (wc > CHARMASK)
                    {
                        WARN("invalid character (%d)\n", *pstr);
                        goto end;
                    }
                }
            }
            *fmtptr |= wc << bitsUsed;
            bitsStored = min(BITS_PER_BYTE - bitsUsed, BITS_IN_CHARMASK);
            if (bitsStored < BITS_IN_CHARMASK)
            {
                wc >>= BITS_PER_BYTE - bitsUsed;
                if (bits + bitsStored == sizeof(FMTID) * BITS_PER_BYTE)
                {
                    if (wc != 0)
                    {
                        WARN("extra bits\n");
                        goto end;
                    }
                    break;
                }
                fmtptr++;
                *fmtptr |= (BYTE)wc;
            }
        }
        hr = S_OK;
    }
end:
    return hr;
}

Referenced by create_EnumSTATPROPSETSTG().

StgConvertPropertyToVariant()

BOOLEAN WINAPI StgConvertPropertyToVariant	(	const SERIALIZEDPROPERTYVALUE *	prop,
		USHORT	CodePage,
		PROPVARIANT *	pvar,
		void *	pma
	)

Definition at line 2795 of file stg_prop.c.

{
    HRESULT hr;
 
    hr = PropertyStorage_ReadProperty(pvar, (const BYTE*)prop, CodePage, Allocate_PMemoryAllocator, pma);
 
    if (FAILED(hr))
    {
        FIXME("should raise C++ exception on failure\n");
        PropVariantInit(pvar);
    }
 
    return FALSE;
}

StgConvertVariantToProperty()

SERIALIZEDPROPERTYVALUE *WINAPI StgConvertVariantToProperty	(	const PROPVARIANT *	pvar,
		USHORT	CodePage,
		SERIALIZEDPROPERTYVALUE *	pprop,
		ULONG *	pcb,
		PROPID	pid,
		BOOLEAN	fReserved,
		ULONG *	pcIndirect
	)

Definition at line 2811 of file stg_prop.c.

{
    FIXME("%p,%d,%p,%p,%d,%d,%p\n", pvar, CodePage, pprop, pcb, pid, fReserved, pcIndirect);
 
    return NULL;
}

StgCreatePropStg()

HRESULT WINAPI StgCreatePropStg	(	IUnknown *	unk,
		REFFMTID	fmt,
		const CLSID *	clsid,
		DWORD	flags,
		DWORD	reserved,
		IPropertyStorage **	prop_stg
	)

Definition at line 2820 of file stg_prop.c.

{
    IStorage *stg;
    IStream *stm;
    HRESULT r;
 
    TRACE("%p %s %s %08x %d %p\n", unk, debugstr_guid(fmt), debugstr_guid(clsid), flags, reserved, prop_stg);
 
    if (!fmt || reserved)
    {
        r = E_INVALIDARG;
        goto end;
    }
 
    if (flags & PROPSETFLAG_NONSIMPLE)
    {
        r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
        if (FAILED(r))
            goto end;
 
        /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to create a
         * storage, not a stream.  For now, disallow it.
         */
        FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
        IStorage_Release(stg);
        r = STG_E_INVALIDFLAG;
    }
    else
    {
        r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
        if (FAILED(r))
            goto end;
 
        r = PropertyStorage_ConstructEmpty(stm, fmt, flags,
                STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
 
        IStream_Release( stm );
    }
 
end:
    TRACE("returning 0x%08x\n", r);
    return r;
}

StgOpenPropStg()

HRESULT WINAPI StgOpenPropStg	(	IUnknown *	unk,
		REFFMTID	fmt,
		DWORD	flags,
		DWORD	reserved,
		IPropertyStorage **	prop_stg
	)

Definition at line 2865 of file stg_prop.c.

{
    IStorage *stg;
    IStream *stm;
    HRESULT r;
 
    TRACE("%p %s %08x %d %p\n", unk, debugstr_guid(fmt), flags, reserved, prop_stg);
 
    if (!fmt || reserved)
    {
        r = E_INVALIDARG;
        goto end;
    }
 
    if (flags & PROPSETFLAG_NONSIMPLE)
    {
        r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
        if (FAILED(r))
            goto end;
 
        /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to open a
         * storage, not a stream.  For now, disallow it.
         */
        FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
        IStorage_Release(stg);
        r = STG_E_INVALIDFLAG;
    }
    else
    {
        r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
        if (FAILED(r))
            goto end;
 
        r = PropertyStorage_ConstructFromStream(stm, fmt,
                STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
 
        IStream_Release( stm );
    }
 
end:
    TRACE("returning 0x%08x\n", r);
    return r;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

storage

)

Variable Documentation

IEnumSTATPROPSETSTG_Vtbl

static const IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTG_Vtbl

static

Initial value:

=
{
    IEnumSTATPROPSETSTG_fnQueryInterface,
    IEnumSTATPROPSETSTG_fnAddRef,
    IEnumSTATPROPSETSTG_fnRelease,
    IEnumSTATPROPSETSTG_fnNext,
    IEnumSTATPROPSETSTG_fnSkip,
    IEnumSTATPROPSETSTG_fnReset,
    IEnumSTATPROPSETSTG_fnClone,
}

Definition at line 145 of file stg_prop.c.

Referenced by create_EnumSTATPROPSETSTG().

IEnumSTATPROPSTG_Vtbl

static const IEnumSTATPROPSTGVtbl IEnumSTATPROPSTG_Vtbl

static

Initial value:

=
{
    IEnumSTATPROPSTG_fnQueryInterface,
    IEnumSTATPROPSTG_fnAddRef,
    IEnumSTATPROPSTG_fnRelease,
    IEnumSTATPROPSTG_fnNext,
    IEnumSTATPROPSTG_fnSkip,
    IEnumSTATPROPSTG_fnReset,
    IEnumSTATPROPSTG_fnClone,
}

Definition at line 146 of file stg_prop.c.

Referenced by create_EnumSTATPROPSTG().

IPropertySetStorage_Vtbl

const IPropertySetStorageVtbl IPropertySetStorage_Vtbl

Initial value:

=
{
    IPropertySetStorage_fnQueryInterface,
    IPropertySetStorage_fnAddRef,
    IPropertySetStorage_fnRelease,
    IPropertySetStorage_fnCreate,
    IPropertySetStorage_fnOpen,
    IPropertySetStorage_fnDelete,
    IPropertySetStorage_fnEnum
}

Definition at line 2557 of file stg_prop.c.

Referenced by StorageImpl_Construct(), and StorageInternalImpl_Construct().

IPropertyStorage_Vtbl

static const IPropertyStorageVtbl IPropertyStorage_Vtbl

static

Initial value:

=
{
    IPropertyStorage_fnQueryInterface,
    IPropertyStorage_fnAddRef,
    IPropertyStorage_fnRelease,
    IPropertyStorage_fnReadMultiple,
    IPropertyStorage_fnWriteMultiple,
    IPropertyStorage_fnDeleteMultiple,
    IPropertyStorage_fnReadPropertyNames,
    IPropertyStorage_fnWritePropertyNames,
    IPropertyStorage_fnDeletePropertyNames,
    IPropertyStorage_fnCommit,
    IPropertyStorage_fnRevert,
    IPropertyStorage_fnEnum,
    IPropertyStorage_fnSetTimes,
    IPropertyStorage_fnSetClass,
    IPropertyStorage_fnStat,
}

Definition at line 144 of file stg_prop.c.

Referenced by PropertyStorage_BaseConstruct().

szDocSummaryInfo

const WCHAR szDocSummaryInfo[]

static

Initial value:

= { 5,'D','o','c','u','m','e','n','t',
 'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0 }

Definition at line 2614 of file stg_prop.c.

Referenced by FmtIdToPropStgName(), PropStgNameToFmtId(), and testFmtId().

szSummaryInfo

const WCHAR szSummaryInfo[]

static

Initial value:

= { 5,'S','u','m','m','a','r','y',
 'I','n','f','o','r','m','a','t','i','o','n',0 }

Definition at line 2612 of file stg_prop.c.

Referenced by FmtIdToPropStgName(), PropStgNameToFmtId(), testFmtId(), and testPropsHelper().