prop.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winerror.h"
#include "winternl.h"
#include "objbase.h"
#include "shlwapi.h"
#include "wine/list.h"
#include "wine/debug.h"
#include "mapival.h"

Include dependency graph for prop.c:

Go to the source code of this file.

Classes
struct	IPropDataItem
struct	IPropDataImpl

Macros
#define	RELOC_PTR(p)   (((char*)(p)) - (char*)lpOld + (char*)lpNew)
#define	CbNewSPropProblemArray(c)    (offsetof(SPropProblemArray,aProblem)+(c)*sizeof(SPropProblem))

Typedefs
typedef struct IPropDataItem *	LPIPropDataItem

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mapi)
BOOL WINAPI	FBadRglpszA (LPSTR *, ULONG)
static ULONG	PROP_BadArray (LPSPropValue lpProp, size_t elemSize)
SCODE WINAPI	PropCopyMore (LPSPropValue lpDest, LPSPropValue lpSrc, ALLOCATEMORE *lpMore, LPVOID lpOrig)
ULONG WINAPI	UlPropSize (LPSPropValue lpProp)
BOOL WINAPI	FPropContainsProp (LPSPropValue lpHaystack, LPSPropValue lpNeedle, ULONG ulFuzzy)
BOOL WINAPI	FPropCompareProp (LPSPropValue lpPropLeft, ULONG ulOp, LPSPropValue lpPropRight)
LONG WINAPI	LPropCompareProp (LPSPropValue lpPropLeft, LPSPropValue lpPropRight)
HRESULT WINAPI	HrGetOneProp (LPMAPIPROP lpIProp, ULONG ulPropTag, LPSPropValue *lppProp)
HRESULT WINAPI	HrSetOneProp (LPMAPIPROP lpIProp, LPSPropValue lpProp)
BOOL WINAPI	FPropExists (LPMAPIPROP lpIProp, ULONG ulPropTag)
LPSPropValue WINAPI	PpropFindProp (LPSPropValue lpProps, ULONG cValues, ULONG ulPropTag)
VOID WINAPI	FreePadrlist (LPADRLIST lpAddrs)
VOID WINAPI	FreeProws (LPSRowSet lpRowSet)
SCODE WINAPI	ScCountProps (INT iCount, LPSPropValue lpProps, ULONG *pcBytes)
SCODE WINAPI	ScCopyProps (int cValues, LPSPropValue lpProps, LPVOID lpDst, ULONG *lpCount)
SCODE WINAPI	ScRelocProps (int cValues, LPSPropValue lpProps, LPVOID lpOld, LPVOID lpNew, ULONG *lpCount)
LPSPropValue WINAPI	LpValFindProp (ULONG ulPropTag, ULONG cValues, LPSPropValue lpProps)
SCODE WINAPI	ScDupPropset (int cValues, LPSPropValue lpProps, LPALLOCATEBUFFER lpAlloc, LPSPropValue *lpNewProp)
BOOL WINAPI	FBadRglpszW (LPWSTR *lppszStrs, ULONG ulCount)
BOOL WINAPI	FBadRowSet (LPSRowSet lpRowSet)
ULONG WINAPI	FBadPropTag (ULONG ulPropTag)
ULONG WINAPI	FBadRow (LPSRow lpRow)
ULONG WINAPI	FBadProp (LPSPropValue lpProp)
ULONG WINAPI	FBadColumnSet (LPSPropTagArray lpCols)
static IPropDataImpl *	impl_from_IPropData (IPropData *iface)
static IPropDataItem *	IMAPIPROP_GetValue (IPropDataImpl *This, ULONG ulPropTag)
static IPropDataItem *	IMAPIPROP_AddValue (IPropDataImpl *This, LPSPropValue lpProp)
static void	IMAPIPROP_Lock (IPropDataImpl *This)
static void	IMAPIPROP_Unlock (IPropDataImpl *This)
static HRESULT WINAPI	IPropData_fnQueryInterface (LPPROPDATA iface, REFIID riid, LPVOID *ppvObj)
static ULONG WINAPI	IPropData_fnAddRef (LPPROPDATA iface)
static ULONG WINAPI	IPropData_fnRelease (LPPROPDATA iface)
static HRESULT WINAPI	IPropData_fnGetLastError (LPPROPDATA iface, HRESULT hRes, ULONG ulFlags, LPMAPIERROR *lppError)
static HRESULT WINAPI	IPropData_fnSaveChanges (LPPROPDATA iface, ULONG ulFlags)
static HRESULT WINAPI	IPropData_fnGetProps (LPPROPDATA iface, LPSPropTagArray lpTags, ULONG ulFlags, ULONG *lpCount, LPSPropValue *lppProps)
static HRESULT WINAPI	IPropData_fnGetPropList (LPPROPDATA iface, ULONG ulFlags, LPSPropTagArray *lppTags)
static HRESULT WINAPI	IPropData_fnOpenProperty (LPPROPDATA iface, ULONG ulPropTag, LPCIID iid, ULONG ulOpts, ULONG ulFlags, LPUNKNOWN *lpUnk)
static HRESULT WINAPI	IPropData_fnSetProps (LPPROPDATA iface, ULONG ulValues, LPSPropValue lpProps, LPSPropProblemArray *lppProbs)
static HRESULT WINAPI	IPropData_fnDeleteProps (LPPROPDATA iface, LPSPropTagArray lpTags, LPSPropProblemArray *lppProbs)
static HRESULT WINAPI	IPropData_fnCopyTo (LPPROPDATA iface, ULONG niids, LPCIID lpiidExcl, LPSPropTagArray lpPropsExcl, ULONG ulParam, LPMAPIPROGRESS lpIProgress, LPCIID lpIfaceIid, LPVOID lpDstObj, ULONG ulFlags, LPSPropProblemArray *lppProbs)
static HRESULT WINAPI	IPropData_fnCopyProps (LPPROPDATA iface, LPSPropTagArray lpInclProps, ULONG ulParam, LPMAPIPROGRESS lpIProgress, LPCIID lpIface, LPVOID lpDstObj, ULONG ulFlags, LPSPropProblemArray *lppProbs)
static HRESULT WINAPI	IPropData_fnGetNamesFromIDs (LPPROPDATA iface, LPSPropTagArray *lppPropTags, LPGUID iid, ULONG ulFlags, ULONG *lpCount, LPMAPINAMEID **lpppNames)
static HRESULT WINAPI	IPropData_fnGetIDsFromNames (LPPROPDATA iface, ULONG ulNames, LPMAPINAMEID *lppNames, ULONG ulFlags, LPSPropTagArray *lppPropTags)
static HRESULT WINAPI	IPropData_fnHrSetObjAccess (LPPROPDATA iface, ULONG ulAccess)
static BOOL	PROP_IsBadAccess (ULONG ulAccess)
static HRESULT WINAPI	IPropData_fnHrSetPropAccess (LPPROPDATA iface, LPSPropTagArray lpTags, ULONG *lpAccess)
static HRESULT WINAPI	IPropData_fnHrGetPropAccess (LPPROPDATA iface, LPSPropTagArray *lppTags, ULONG **lppAccess)
static HRESULT WINAPI	IPropData_fnHrAddObjProps (LPPROPDATA iface, LPSPropTagArray lpTags, LPSPropProblemArray *lppProbs)
SCODE WINAPI	CreateIProp (LPCIID iid, ALLOCATEBUFFER *lpAlloc, ALLOCATEMORE *lpMore, FREEBUFFER *lpFree, LPVOID lpReserved, LPPROPDATA *lppPropData)

Variables
static const IPropDataVtbl	IPropDataImpl_vtbl

Macro Definition Documentation

CbNewSPropProblemArray

#define CbNewSPropProblemArray

(

c

)

(offsetof(SPropProblemArray,aProblem)+(c)*sizeof(SPropProblem))

Definition at line 1491 of file prop.c.

RELOC_PTR

#define RELOC_PTR

(

p

)

(((char*)(p)) - (char*)lpOld + (char*)lpNew)

Typedef Documentation

LPIPropDataItem

typedef struct IPropDataItem * LPIPropDataItem

Function Documentation

CreateIProp()

SCODE WINAPI CreateIProp	(	LPCIID	iid,
		ALLOCATEBUFFER *	lpAlloc,
		ALLOCATEMORE *	lpMore,
		FREEBUFFER *	lpFree,
		LPVOID	lpReserved,
		LPPROPDATA *	lppPropData
	)

Definition at line 2307 of file prop.c.

{
    IPropDataImpl *lpPropData;
    SCODE scode;
 
    TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_guid(iid), lpAlloc, lpMore, lpFree,
          lpReserved, lppPropData);
 
    if (lppPropData)
        *lppPropData = NULL;
 
    if (iid && !IsEqualGUID(iid, &IID_IMAPIPropData))
        return MAPI_E_INTERFACE_NOT_SUPPORTED;
 
    if (!lpAlloc || !lpMore || !lpFree || lpReserved || !lppPropData)
        return MAPI_E_INVALID_PARAMETER;
 
    scode = lpAlloc(sizeof(IPropDataImpl), (LPVOID*)&lpPropData);
 
    if (SUCCEEDED(scode))
    {
        lpPropData->IPropData_iface.lpVtbl = &IPropDataImpl_vtbl;
        lpPropData->lRef = 1;
        lpPropData->lpAlloc = lpAlloc;
        lpPropData->lpMore = lpMore;
        lpPropData->lpFree = lpFree;
        lpPropData->ulObjAccess = IPROP_READWRITE;
        lpPropData->ulNumValues = 0;
        list_init(&lpPropData->values);
        InitializeCriticalSection(&lpPropData->cs);
        lpPropData->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IPropDataImpl.cs");
        *lppPropData = &lpPropData->IPropData_iface;
    }
    return scode;
}

FBadColumnSet()

ULONG WINAPI FBadColumnSet

(

LPSPropTagArray

lpCols

)

Definition at line 1357 of file prop.c.

{
    ULONG ulRet = FALSE, i;
 
    TRACE("(%p)\n", lpCols);
 
    if (!lpCols || IsBadReadPtr(lpCols, CbSPropTagArray(lpCols)))
        ulRet = TRUE;
    else
    {
        for (i = 0; i < lpCols->cValues; i++)
        {
            if ((lpCols->aulPropTag[i] & PROP_TYPE_MASK) == PT_ERROR ||
                FBadPropTag(lpCols->aulPropTag[i]))
            {
                ulRet = TRUE;
                break;
            }
        }
    }
    TRACE("Returning %s\n", ulRet ? "TRUE" : "FALSE");
    return ulRet;
}

FBadProp()

ULONG WINAPI FBadProp

(

LPSPropValue

lpProp

)

Definition at line 1288 of file prop.c.

{
    if (!lpProp || IsBadReadPtr(lpProp, sizeof(SPropValue)) ||
        FBadPropTag(lpProp->ulPropTag))
        return TRUE;
 
    switch (PROP_TYPE(lpProp->ulPropTag))
    {
    /* Single value properties containing pointers */
    case PT_STRING8:
        if (!lpProp->Value.lpszA || IsBadStringPtrA(lpProp->Value.lpszA, -1))
            return TRUE;
        break;
    case PT_UNICODE:
        if (!lpProp->Value.lpszW || IsBadStringPtrW(lpProp->Value.lpszW, -1))
            return TRUE;
        break;
    case PT_BINARY:
        if (IsBadReadPtr(lpProp->Value.bin.lpb, lpProp->Value.bin.cb))
            return TRUE;
        break;
    case PT_CLSID:
        if (IsBadReadPtr(lpProp->Value.lpguid, sizeof(GUID)))
            return TRUE;
        break;
 
    /* Multiple value properties (arrays) containing no pointers */
    case PT_MV_I2:
        return PROP_BadArray(lpProp, sizeof(SHORT));
    case PT_MV_LONG:
        return PROP_BadArray(lpProp, sizeof(LONG));
    case PT_MV_LONGLONG:
        return PROP_BadArray(lpProp, sizeof(LONG64));
    case PT_MV_FLOAT:
        return PROP_BadArray(lpProp, sizeof(float));
    case PT_MV_SYSTIME:
        return PROP_BadArray(lpProp, sizeof(FILETIME));
    case PT_MV_APPTIME:
    case PT_MV_DOUBLE:
        return PROP_BadArray(lpProp, sizeof(double));
    case PT_MV_CURRENCY:
        return PROP_BadArray(lpProp, sizeof(CY));
    case PT_MV_CLSID:
        return PROP_BadArray(lpProp, sizeof(GUID));
 
    /* Multiple value properties containing pointers */
    case PT_MV_STRING8:
        return FBadRglpszA(lpProp->Value.MVszA.lppszA,
                           lpProp->Value.MVszA.cValues);
    case PT_MV_UNICODE:
        return FBadRglpszW(lpProp->Value.MVszW.lppszW,
                           lpProp->Value.MVszW.cValues);
    case PT_MV_BINARY:
        return FBadEntryList(&lpProp->Value.MVbin);
    }
    return FALSE;
}

Referenced by FBadRow(), FPropCompareProp(), FPropContainsProp(), IPropData_fnSetProps(), PropCopyMore(), and ScCountProps().

FBadPropTag()

ULONG WINAPI FBadPropTag

(

ULONG

ulPropTag

)

Definition at line 1221 of file prop.c.

{
    TRACE("(0x%08x)\n", ulPropTag);
 
    switch (ulPropTag & (~MV_FLAG & PROP_TYPE_MASK))
    {
    case PT_UNSPECIFIED:
    case PT_NULL:
    case PT_I2:
    case PT_LONG:
    case PT_R4:
    case PT_DOUBLE:
    case PT_CURRENCY:
    case PT_APPTIME:
    case PT_ERROR:
    case PT_BOOLEAN:
    case PT_OBJECT:
    case PT_I8:
    case PT_STRING8:
    case PT_UNICODE:
    case PT_SYSTIME:
    case PT_CLSID:
    case PT_BINARY:
        return FALSE;
    }
    return TRUE;
}

Referenced by FBadColumnSet(), FBadProp(), FPropExists(), IPropData_fnDeleteProps(), IPropData_fnHrSetPropAccess(), and PpropFindProp().

FBadRglpszA()

BOOL WINAPI FBadRglpszA	(	LPSTR *	lppszStrs,
		ULONG	ulCount
	)

Definition at line 1138 of file prop.c.

{
    ULONG i;
 
    TRACE("(%p,%d)\n", lppszStrs, ulCount);
 
    if (!ulCount)
        return FALSE;
 
    if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR)))
        return TRUE;
 
    for (i = 0; i < ulCount; i++)
    {
        if (!lppszStrs[i] || IsBadStringPtrA(lppszStrs[i], -1))
            return TRUE;
    }
    return FALSE;
}

Referenced by FBadProp().

FBadRglpszW()

BOOL WINAPI FBadRglpszW	(	LPWSTR *	lppszStrs,
		ULONG	ulCount
	)

Definition at line 1163 of file prop.c.

{
    ULONG i;
 
    TRACE("(%p,%d)\n", lppszStrs, ulCount);
 
    if (!ulCount)
        return FALSE;
 
    if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR)))
        return TRUE;
 
    for (i = 0; i < ulCount; i++)
    {
        if (!lppszStrs[i] || IsBadStringPtrW(lppszStrs[i], -1))
            return TRUE;
    }
    return FALSE;
}

Referenced by FBadProp().

FBadRow()

ULONG WINAPI FBadRow

(

LPSRow

lpRow

)

Definition at line 1260 of file prop.c.

{
    ULONG i;
    TRACE("(%p)\n", lpRow);
 
    if (!lpRow || IsBadReadPtr(lpRow, sizeof(SRow)) || !lpRow->lpProps ||
        IsBadReadPtr(lpRow->lpProps, lpRow->cValues * sizeof(SPropValue)))
        return TRUE;
 
    for (i = 0; i < lpRow->cValues; i++)
    {
        if (FBadProp(&lpRow->lpProps[i]))
            return TRUE;
    }
    return FALSE;
}

Referenced by FBadRowSet().

FBadRowSet()

BOOL WINAPI FBadRowSet

(

LPSRowSet

lpRowSet

)

Definition at line 1194 of file prop.c.

{
    ULONG i;
    TRACE("(%p)\n", lpRowSet);
 
    if (!lpRowSet || IsBadReadPtr(lpRowSet, CbSRowSet(lpRowSet)))
        return TRUE;
 
    for (i = 0; i < lpRowSet->cRows; i++)
    {
        if (FBadRow(&lpRowSet->aRow[i]))
            return TRUE;
    }
    return FALSE;
}

FPropCompareProp()

BOOL WINAPI FPropCompareProp	(	LPSPropValue	lpPropLeft,
		ULONG	ulOp,
		LPSPropValue	lpPropRight
	)

Definition at line 399 of file prop.c.

{
    LONG iCmp;
 
    TRACE("(%p,%d,%p)\n", lpPropLeft, ulOp, lpPropRight);
 
    if (ulOp > RELOP_RE || FBadProp(lpPropLeft) || FBadProp(lpPropRight))
        return FALSE;
 
    if (ulOp == RELOP_RE)
    {
        FIXME("Comparison operator RELOP_RE not yet implemented!\n");
        return FALSE;
    }
 
    iCmp = LPropCompareProp(lpPropLeft, lpPropRight);
 
    switch (ulOp)
    {
    case RELOP_LT: return iCmp <  0;
    case RELOP_LE: return iCmp <= 0;
    case RELOP_GT: return iCmp >  0;
    case RELOP_GE: return iCmp >= 0;
    case RELOP_EQ: return iCmp == 0;
    case RELOP_NE: return iCmp != 0;
    }
    return FALSE;
}

FPropContainsProp()

BOOL WINAPI FPropContainsProp	(	LPSPropValue	lpHaystack,
		LPSPropValue	lpNeedle,
		ULONG	ulFuzzy
	)

Definition at line 300 of file prop.c.

{
    TRACE("(%p,%p,0x%08x)\n", lpHaystack, lpNeedle, ulFuzzy);
 
    if (FBadProp(lpHaystack) || FBadProp(lpNeedle) ||
        PROP_TYPE(lpHaystack->ulPropTag) != PROP_TYPE(lpNeedle->ulPropTag))
        return FALSE;
 
    /* FIXME: Do later versions support Unicode as well? */
 
    if (PROP_TYPE(lpHaystack->ulPropTag) == PT_STRING8)
    {
        DWORD dwFlags = 0, dwNeedleLen, dwHaystackLen;
 
        if (ulFuzzy & FL_IGNORECASE)
            dwFlags |= NORM_IGNORECASE;
        if (ulFuzzy & FL_IGNORENONSPACE)
            dwFlags |= NORM_IGNORENONSPACE;
        if (ulFuzzy & FL_LOOSE)
            dwFlags |= (NORM_IGNORECASE|NORM_IGNORENONSPACE|NORM_IGNORESYMBOLS);
 
        dwNeedleLen = lstrlenA(lpNeedle->Value.lpszA);
        dwHaystackLen = lstrlenA(lpHaystack->Value.lpszA);
 
        if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
        {
            if (dwNeedleLen <= dwHaystackLen &&
                CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
                               lpHaystack->Value.lpszA, dwNeedleLen,
                               lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
                return TRUE; /* needle is a prefix of haystack */
        }
        else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
        {
            LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD) = StrChrA;
            LPSTR lpStr = lpHaystack->Value.lpszA;
 
            if (dwFlags & NORM_IGNORECASE)
                pStrChrFn = StrChrIA;
 
            while ((lpStr = pStrChrFn(lpStr, *lpNeedle->Value.lpszA)) != NULL)
            {
                dwHaystackLen -= (lpStr - lpHaystack->Value.lpszA);
                if (dwNeedleLen <= dwHaystackLen &&
                    CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
                               lpStr, dwNeedleLen,
                               lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
                    return TRUE; /* needle is a substring of haystack */
                lpStr++;
            }
        }
        else if (CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
                                lpHaystack->Value.lpszA, dwHaystackLen,
                                lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
            return TRUE; /* full string match */
    }
    else if (PROP_TYPE(lpHaystack->ulPropTag) == PT_BINARY)
    {
        if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
        {
            if (lpNeedle->Value.bin.cb <= lpHaystack->Value.bin.cb &&
                !memcmp(lpNeedle->Value.bin.lpb, lpHaystack->Value.bin.lpb,
                        lpNeedle->Value.bin.cb))
                return TRUE; /* needle is a prefix of haystack */
        }
        else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
        {
            ULONG ulLen = lpHaystack->Value.bin.cb;
            LPBYTE lpb = lpHaystack->Value.bin.lpb;
 
            while ((lpb = memchr(lpb, *lpNeedle->Value.bin.lpb, ulLen)) != NULL)
            {
                ulLen = lpHaystack->Value.bin.cb - (lpb - lpHaystack->Value.bin.lpb);
                if (lpNeedle->Value.bin.cb <= ulLen &&
                    !memcmp(lpNeedle->Value.bin.lpb, lpb, lpNeedle->Value.bin.cb))
                    return TRUE; /* needle is a substring of haystack */
                lpb++;
            }
        }
        else if (!LPropCompareProp(lpHaystack, lpNeedle))
            return TRUE; /* needle is an exact match with haystack */
 
    }
    return FALSE;
}

FPropExists()

BOOL WINAPI FPropExists	(	LPMAPIPROP	lpIProp,
		ULONG	ulPropTag
	)

Definition at line 592 of file prop.c.

 {
    BOOL bRet = FALSE;
 
    TRACE("(%p,%d)\n", lpIProp, ulPropTag);
 
    if (lpIProp)
    {
        LPSPropTagArray lpTags;
        ULONG i;
 
        if (FAILED(IMAPIProp_GetPropList(lpIProp, 0u, &lpTags)))
            return FALSE;
 
        for (i = 0; i < lpTags->cValues; i++)
        {
            if (!FBadPropTag(lpTags->aulPropTag[i]) &&
                (lpTags->aulPropTag[i] == ulPropTag ||
                 (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
                  PROP_ID(lpTags->aulPropTag[i]) == lpTags->aulPropTag[i])))
            {
                bRet = TRUE;
                break;
            }
        }
        MAPIFreeBuffer(lpTags);
    }
    return bRet;
}

FreePadrlist()

VOID WINAPI FreePadrlist

(

LPADRLIST

lpAddrs

)

Definition at line 669 of file prop.c.

{
    TRACE("(%p)\n", lpAddrs);
 
    /* Structures are binary compatible; use the same implementation */
    FreeProws((LPSRowSet)lpAddrs);
}

FreeProws()

VOID WINAPI FreeProws

(

LPSRowSet

lpRowSet

)

Definition at line 688 of file prop.c.

{
    TRACE("(%p)\n", lpRowSet);
 
    if (lpRowSet)
    {
        ULONG i;
 
        for (i = 0; i < lpRowSet->cRows; i++)
            MAPIFreeBuffer(lpRowSet->aRow[i].lpProps);
 
        MAPIFreeBuffer(lpRowSet);
    }
}

Referenced by FreePadrlist(), and sendmail_extended_mapi().

HrGetOneProp()

HRESULT WINAPI HrGetOneProp	(	LPMAPIPROP	lpIProp,
		ULONG	ulPropTag,
		LPSPropValue *	lppProp
	)

Definition at line 535 of file prop.c.

{
    SPropTagArray pta;
    ULONG ulCount;
    HRESULT hRet;
 
    TRACE("(%p,%d,%p)\n", lpIProp, ulPropTag, lppProp);
 
    pta.cValues = 1u;
    pta.aulPropTag[0] = ulPropTag;
    hRet = IMAPIProp_GetProps(lpIProp, &pta, 0u, &ulCount, lppProp);
    if (hRet == MAPI_W_ERRORS_RETURNED)
    {
        MAPIFreeBuffer(*lppProp);
        *lppProp = NULL;
        hRet = MAPI_E_NOT_FOUND;
    }
    return hRet;
}

HrSetOneProp()

HRESULT WINAPI HrSetOneProp	(	LPMAPIPROP	lpIProp,
		LPSPropValue	lpProp
	)

Definition at line 568 of file prop.c.

{
    TRACE("(%p,%p)\n", lpIProp, lpProp);
 
    return IMAPIProp_SetProps(lpIProp, 1u, lpProp, NULL);
}

IMAPIPROP_AddValue()

static IPropDataItem * IMAPIPROP_AddValue ( IPropDataImpl *  This, LPSPropValue  lpProp  )

static

Definition at line 1443 of file prop.c.

{
    LPVOID lpMem;
    LPIPropDataItem lpNew;
    HRESULT hRet;
 
    hRet = This->lpAlloc(sizeof(IPropDataItem), &lpMem);
 
    if (SUCCEEDED(hRet))
    {
        lpNew = lpMem;
        lpNew->ulAccess = IPROP_READWRITE;
 
        /* Allocate the value separately so we can update it easily */
        lpMem = NULL;
        hRet = This->lpAlloc(sizeof(SPropValue), &lpMem);
        if (SUCCEEDED(hRet))
        {
            lpNew->value = lpMem;
 
            hRet = PropCopyMore(lpNew->value, lpProp, This->lpMore, lpMem);
            if (SUCCEEDED(hRet))
            {
                list_add_tail(&This->values, &lpNew->entry);
                This->ulNumValues++;
                return lpNew;
            }
            This->lpFree(lpNew->value);
        }
        This->lpFree(lpNew);
    }
    return NULL;
}

Referenced by IPropData_fnSetProps().

IMAPIPROP_GetValue()

static IPropDataItem * IMAPIPROP_GetValue ( IPropDataImpl *  This, ULONG  ulPropTag  )

static

Definition at line 1428 of file prop.c.

{
    struct list *cursor;
 
    LIST_FOR_EACH(cursor, &This->values)
    {
        LPIPropDataItem current = LIST_ENTRY(cursor, IPropDataItem, entry);
        /* Note that property types don't have to match, just Id's */
        if (PROP_ID(current->value->ulPropTag) == PROP_ID(ulPropTag))
            return current;
    }
    return NULL;
}

Referenced by IPropData_fnDeleteProps(), IPropData_fnGetProps(), IPropData_fnHrSetPropAccess(), and IPropData_fnSetProps().

IMAPIPROP_Lock()

static void IMAPIPROP_Lock ( IPropDataImpl *  This )

inlinestatic

Definition at line 1479 of file prop.c.

{
    EnterCriticalSection(&This->cs);
}

Referenced by IPropData_fnDeleteProps(), IPropData_fnGetPropList(), IPropData_fnGetProps(), IPropData_fnHrGetPropAccess(), IPropData_fnHrSetObjAccess(), IPropData_fnHrSetPropAccess(), and IPropData_fnSetProps().

IMAPIPROP_Unlock()

static void IMAPIPROP_Unlock ( IPropDataImpl *  This )

inlinestatic

Definition at line 1485 of file prop.c.

{
    LeaveCriticalSection(&This->cs);
}

Referenced by IPropData_fnDeleteProps(), IPropData_fnGetPropList(), IPropData_fnGetProps(), IPropData_fnHrGetPropAccess(), IPropData_fnHrSetObjAccess(), IPropData_fnHrSetPropAccess(), and IPropData_fnSetProps().

impl_from_IPropData()

static IPropDataImpl * impl_from_IPropData ( IPropData *  iface )

inlinestatic

Definition at line 1422 of file prop.c.

{
    return CONTAINING_RECORD(iface, IPropDataImpl, IPropData_iface);
}

Referenced by IPropData_fnAddRef(), IPropData_fnDeleteProps(), IPropData_fnGetPropList(), IPropData_fnGetProps(), IPropData_fnHrGetPropAccess(), IPropData_fnHrSetObjAccess(), IPropData_fnHrSetPropAccess(), IPropData_fnQueryInterface(), IPropData_fnRelease(), and IPropData_fnSetProps().

IPropData_fnAddRef()

static ULONG WINAPI IPropData_fnAddRef ( LPPROPDATA  iface )

static

Definition at line 1531 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
 
    TRACE("(%p)->(count before=%u)\n", This, This->lRef);
 
    return InterlockedIncrement(&This->lRef);
}

IPropData_fnCopyProps()

static HRESULT WINAPI IPropData_fnCopyProps ( LPPROPDATA  iface, LPSPropTagArray  lpInclProps, ULONG  ulParam, LPMAPIPROGRESS  lpIProgress, LPCIID  lpIface, LPVOID  lpDstObj, ULONG  ulFlags, LPSPropProblemArray *  lppProbs  )

static

Definition at line 1980 of file prop.c.

{
    FIXME("(%p,%p,%x,%p,%s,%p,0x%08X,%p) stub\n", iface, lpInclProps,
          ulParam, lpIProgress, debugstr_guid(lpIface), lpDstObj, ulFlags,
          lppProbs);
    return MAPI_E_NO_SUPPORT;
}

IPropData_fnCopyTo()

static HRESULT WINAPI IPropData_fnCopyTo ( LPPROPDATA  iface, ULONG  niids, LPCIID  lpiidExcl, LPSPropTagArray  lpPropsExcl, ULONG  ulParam, LPMAPIPROGRESS  lpIProgress, LPCIID  lpIfaceIid, LPVOID  lpDstObj, ULONG  ulFlags, LPSPropProblemArray *  lppProbs  )

static

Definition at line 1960 of file prop.c.

{
    FIXME("(%p,%u,%p,%p,%x,%p,%s,%p,0x%08X,%p) stub\n", iface, niids,
          lpiidExcl, lpPropsExcl, ulParam, lpIProgress,
          debugstr_guid(lpIfaceIid), lpDstObj, ulFlags, lppProbs);
    return MAPI_E_NO_SUPPORT;
}

IPropData_fnDeleteProps()

static HRESULT WINAPI IPropData_fnDeleteProps ( LPPROPDATA  iface, LPSPropTagArray  lpTags, LPSPropProblemArray *  lppProbs  )

static

Definition at line 1877 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    ULONG i, numProbs = 0;
    HRESULT hRet = S_OK;
 
    TRACE("(%p,%p,%p)\n", iface, lpTags, lppProbs);
 
    if (!iface || !lpTags)
        return MAPI_E_INVALID_PARAMETER;
 
    if (lppProbs)
        *lppProbs = NULL;
 
    for (i = 0; i < lpTags->cValues; i++)
    {
        if (FBadPropTag(lpTags->aulPropTag[i]) ||
            PROP_TYPE(lpTags->aulPropTag[i]) == PT_OBJECT ||
            PROP_TYPE(lpTags->aulPropTag[i]) == PT_NULL)
          return MAPI_E_INVALID_PARAMETER;
    }
 
    IMAPIPROP_Lock(This);
 
    if (This->ulObjAccess != IPROP_READWRITE)
    {
        IMAPIPROP_Unlock(This);
        return E_ACCESSDENIED;
    }
 
    for (i = 0; i < lpTags->cValues; i++)
    {
        LPIPropDataItem item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
 
        if (item)
        {
            if (item->ulAccess & IPROP_READWRITE)
            {
                /* Everything hunky-dory, remove the item */
                list_remove(&item->entry);
                This->lpFree(item->value); /* Also frees value pointers */
                This->lpFree(item);
                This->ulNumValues--;
            }
            else if (lppProbs)
            {
                 /* Can't write the value. Create/populate problems array */
                 if (!*lppProbs)
                 {
                     /* Create problems array */
                     ULONG ulSize = CbNewSPropProblemArray(lpTags->cValues - i);
                     HRESULT hRetTmp = MAPIAllocateBuffer(ulSize, (LPVOID*)lppProbs);
                     if (FAILED(hRetTmp))
                         hRet = hRetTmp;
                 }
                 if (*lppProbs)
                 {
                     LPSPropProblem lpProb = &(*lppProbs)->aProblem[numProbs];
                     lpProb->ulIndex = i;
                     lpProb->ulPropTag = lpTags->aulPropTag[i];
                     lpProb->scode = E_ACCESSDENIED;
                     numProbs++;
                 }
            }
        }
    }
    if (lppProbs && *lppProbs)
        (*lppProbs)->cProblem = numProbs;
 
    IMAPIPROP_Unlock(This);
    return hRet;
}

IPropData_fnGetIDsFromNames()

static HRESULT WINAPI IPropData_fnGetIDsFromNames ( LPPROPDATA  iface, ULONG  ulNames, LPMAPINAMEID *  lppNames, ULONG  ulFlags, LPSPropTagArray *  lppPropTags  )

static

Definition at line 2044 of file prop.c.

{
    FIXME("(%p,%d,%p,0x%08X,%p) stub\n",
          iface, ulNames, lppNames, ulFlags, lppPropTags);
    return MAPI_E_NO_SUPPORT;
}

IPropData_fnGetLastError()

static HRESULT WINAPI IPropData_fnGetLastError ( LPPROPDATA  iface, HRESULT  hRes, ULONG  ulFlags, LPMAPIERROR *  lppError  )

static

Definition at line 1596 of file prop.c.

{
    TRACE("(%p,0x%08X,0x%08X,%p)\n", iface, hRes, ulFlags, lppError);
 
    if (!lppError  || SUCCEEDED(hRes) || (ulFlags & ~MAPI_UNICODE))
        return MAPI_E_INVALID_PARAMETER;
 
    *lppError = NULL;
    return S_OK;
}

IPropData_fnGetNamesFromIDs()

static HRESULT WINAPI IPropData_fnGetNamesFromIDs ( LPPROPDATA  iface, LPSPropTagArray *  lppPropTags, LPGUID  iid, ULONG  ulFlags, ULONG *  lpCount, LPMAPINAMEID **  lpppNames  )

static

Definition at line 2014 of file prop.c.

{
    FIXME("(%p,%p,%s,0x%08X,%p,%p) stub\n", iface, lppPropTags,
          debugstr_guid(iid), ulFlags, lpCount, lpppNames);
    return MAPI_E_NO_SUPPORT;
}

IPropData_fnGetPropList()

static HRESULT WINAPI IPropData_fnGetPropList ( LPPROPDATA  iface, ULONG  ulFlags, LPSPropTagArray *  lppTags  )

static

Definition at line 1720 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    ULONG i;
    HRESULT hRet;
 
    TRACE("(%p,0x%08x,%p) stub\n", iface, ulFlags, lppTags);
 
    if (!iface || ulFlags & ~MAPI_UNICODE || !lppTags)
        return MAPI_E_INVALID_PARAMETER;
 
    FIXME("semi-stub, flags not supported\n");
 
    *lppTags = NULL;
 
    IMAPIPROP_Lock(This);
 
    hRet = MAPIAllocateBuffer(CbNewSPropTagArray(This->ulNumValues),
                              (LPVOID*)lppTags);
    if (SUCCEEDED(hRet))
    {
        struct list *cursor;
 
        i = 0;
        LIST_FOR_EACH(cursor, &This->values)
        {
            LPIPropDataItem current = LIST_ENTRY(cursor, IPropDataItem, entry);
            (*lppTags)->aulPropTag[i] = current->value->ulPropTag;
            i++;
        }
        (*lppTags)->cValues = This->ulNumValues;
    }
 
    IMAPIPROP_Unlock(This);
    return hRet;
}

IPropData_fnGetProps()

static HRESULT WINAPI IPropData_fnGetProps ( LPPROPDATA  iface, LPSPropTagArray  lpTags, ULONG  ulFlags, ULONG *  lpCount, LPSPropValue *  lppProps  )

static

Definition at line 1654 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    ULONG i;
    HRESULT hRet = S_OK;
 
    TRACE("(%p,%p,0x%08x,%p,%p) stub\n", iface, lpTags, ulFlags,
          lpCount, lppProps);
 
    if (!iface || ulFlags & ~MAPI_UNICODE || !lpTags || *lpCount || !lppProps)
        return MAPI_E_INVALID_PARAMETER;
 
    FIXME("semi-stub, flags not supported\n");
 
    *lpCount = lpTags->cValues;
    *lppProps = NULL;
 
    if (*lpCount)
    {
        hRet = MAPIAllocateBuffer(*lpCount * sizeof(SPropValue), (LPVOID*)lppProps);
        if (FAILED(hRet))
            return hRet;
 
        IMAPIPROP_Lock(This);
 
        for (i = 0; i < lpTags->cValues; i++)
        {
            HRESULT hRetTmp = E_INVALIDARG;
            LPIPropDataItem item;
 
            item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
 
            if (item)
                hRetTmp = PropCopyMore(&(*lppProps)[i], item->value,
                                       This->lpMore, *lppProps);
            if (FAILED(hRetTmp))
            {
                hRet = MAPI_W_ERRORS_RETURNED;
                (*lppProps)[i].ulPropTag =
                    CHANGE_PROP_TYPE(lpTags->aulPropTag[i], PT_ERROR);
            }
        }
 
        IMAPIPROP_Unlock(This);
    }
    return hRet;
}

IPropData_fnHrAddObjProps()

static HRESULT WINAPI IPropData_fnHrAddObjProps ( LPPROPDATA  iface, LPSPropTagArray  lpTags, LPSPropProblemArray *  lppProbs  )

static

Definition at line 2230 of file prop.c.

{
#if 0
    ULONG i;
    HRESULT hRet;
    LPSPropValue lpValues;
#endif
 
    FIXME("(%p,%p,%p) stub\n", iface, lpTags, lppProbs);
 
    if (!iface || !lpTags)
        return MAPI_E_INVALID_PARAMETER;
 
    /* FIXME: Below is the obvious implementation, adding all the properties
     *        in lpTags to the object. However, it doesn't appear that this
     *        is what this function does.
     */
    return S_OK;
#if 0
    if (!lpTags->cValues)
        return S_OK;
 
    lpValues = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                         lpTags->cValues * sizeof(SPropValue));
    if (!lpValues)
        return MAPI_E_NOT_ENOUGH_MEMORY;
 
    for (i = 0; i < lpTags->cValues; i++)
        lpValues[i].ulPropTag = lpTags->aulPropTag[i];
 
    hRet = IPropData_SetProps(iface, lpTags->cValues, lpValues, lppProbs);
    HeapFree(GetProcessHeap(), 0, lpValues);
    return hRet;
#endif
}

IPropData_fnHrGetPropAccess()

static HRESULT WINAPI IPropData_fnHrGetPropAccess ( LPPROPDATA  iface, LPSPropTagArray *  lppTags, ULONG **  lppAccess  )

static

Definition at line 2172 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    LPVOID lpMem;
    HRESULT hRet;
    ULONG i;
 
    TRACE("(%p,%p,%p) stub\n", iface, lppTags, lppAccess);
 
    if (!iface || !lppTags || !lppAccess)
        return MAPI_E_INVALID_PARAMETER;
 
    *lppTags = NULL;
    *lppAccess = NULL;
 
    IMAPIPROP_Lock(This);
 
    hRet = This->lpAlloc(CbNewSPropTagArray(This->ulNumValues), &lpMem);
    if (SUCCEEDED(hRet))
    {
        *lppTags = lpMem;
 
        hRet = This->lpAlloc(This->ulNumValues * sizeof(ULONG), &lpMem);
        if (SUCCEEDED(hRet))
        {
            struct list *cursor;
 
            *lppAccess = lpMem;
            (*lppTags)->cValues = This->ulNumValues;
 
            i = 0;
            LIST_FOR_EACH(cursor, &This->values)
            {
                LPIPropDataItem item = LIST_ENTRY(cursor, IPropDataItem, entry);
                (*lppTags)->aulPropTag[i] = item->value->ulPropTag;
                (*lppAccess)[i] = item->ulAccess;
                i++;
            }
            IMAPIPROP_Unlock(This);
            return S_OK;
        }
        This->lpFree(*lppTags);
        *lppTags = 0;
    }
    IMAPIPROP_Unlock(This);
    return MAPI_E_NOT_ENOUGH_MEMORY;
}

IPropData_fnHrSetObjAccess()

static HRESULT WINAPI IPropData_fnHrSetObjAccess ( LPPROPDATA  iface, ULONG  ulAccess  )

static

Definition at line 2068 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
 
    TRACE("(%p,%x)\n", iface, ulAccess);
 
    if (!iface || ulAccess < IPROP_READONLY || ulAccess > IPROP_READWRITE)
        return MAPI_E_INVALID_PARAMETER;
 
    IMAPIPROP_Lock(This);
 
    This->ulObjAccess = ulAccess;
 
    IMAPIPROP_Unlock(This);
    return S_OK;
}

IPropData_fnHrSetPropAccess()

static HRESULT WINAPI IPropData_fnHrSetPropAccess ( LPPROPDATA  iface, LPSPropTagArray  lpTags, ULONG *  lpAccess  )

static

Definition at line 2121 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    ULONG i;
 
    TRACE("(%p,%p,%p)\n", iface, lpTags, lpAccess);
 
    if (!iface || !lpTags || !lpAccess)
        return MAPI_E_INVALID_PARAMETER;
 
    for (i = 0; i < lpTags->cValues; i++)
    {
        if (FBadPropTag(lpTags->aulPropTag[i]) || PROP_IsBadAccess(lpAccess[i]))
            return MAPI_E_INVALID_PARAMETER;
    }
 
    IMAPIPROP_Lock(This);
 
    for (i = 0; i < lpTags->cValues; i++)
    {
        LPIPropDataItem item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
 
        if (item)
            item->ulAccess = lpAccess[i];
    }
 
    IMAPIPROP_Unlock(This);
    return S_OK;
}

IPropData_fnOpenProperty()

static HRESULT WINAPI IPropData_fnOpenProperty ( LPPROPDATA  iface, ULONG  ulPropTag, LPCIID  iid, ULONG  ulOpts, ULONG  ulFlags, LPUNKNOWN *  lpUnk  )

static

Definition at line 1766 of file prop.c.

{
    FIXME("(%p,%u,%s,%u,0x%08x,%p) stub\n", iface, ulPropTag,
          debugstr_guid(iid), ulOpts, ulFlags, lpUnk);
    return MAPI_E_NO_SUPPORT;
}

IPropData_fnQueryInterface()

static HRESULT WINAPI IPropData_fnQueryInterface ( LPPROPDATA  iface, REFIID  riid, LPVOID *  ppvObj  )

static

Definition at line 1500 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
 
    TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj);
 
    if (!ppvObj || !riid)
        return MAPI_E_INVALID_PARAMETER;
 
    *ppvObj = NULL;
 
    if(IsEqualIID(riid, &IID_IUnknown) ||
       IsEqualIID(riid, &IID_IMAPIProp) ||
       IsEqualIID(riid, &IID_IMAPIPropData))
    {
        *ppvObj = &This->IPropData_iface;
        IPropData_AddRef(iface);
        TRACE("returning %p\n", *ppvObj);
        return S_OK;
    }
 
    TRACE("returning E_NOINTERFACE\n");
    return MAPI_E_INTERFACE_NOT_SUPPORTED;
}

IPropData_fnRelease()

static ULONG WINAPI IPropData_fnRelease ( LPPROPDATA  iface )

static

Definition at line 1546 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    LONG lRef;
 
    TRACE("(%p)->(count before=%u)\n", This, This->lRef);
 
    lRef = InterlockedDecrement(&This->lRef);
    if (!lRef)
    {
        TRACE("Destroying IPropData (%p)\n",This);
 
        /* Note: No need to lock, since no other thread is referencing iface */
        while (!list_empty(&This->values))
        {
            struct list *head = list_head(&This->values);
            LPIPropDataItem current = LIST_ENTRY(head, IPropDataItem, entry);
            list_remove(head);
            This->lpFree(current->value);
            This->lpFree(current);
        }
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        This->lpFree(This);
    }
    return (ULONG)lRef;
}

IPropData_fnSaveChanges()

static HRESULT WINAPI IPropData_fnSaveChanges ( LPPROPDATA  iface, ULONG  ulFlags  )

static

Definition at line 1621 of file prop.c.

{
    TRACE("(%p,0x%08X)\n", iface, ulFlags);
 
     /* Since this object is not transacted we do not need to implement this */
     /* FIXME: Should we set the access levels to clean? */
    return S_OK;
}

IPropData_fnSetProps()

static HRESULT WINAPI IPropData_fnSetProps ( LPPROPDATA  iface, ULONG  ulValues, LPSPropValue  lpProps, LPSPropProblemArray *  lppProbs  )

static

Definition at line 1791 of file prop.c.

{
    IPropDataImpl *This = impl_from_IPropData(iface);
    HRESULT hRet = S_OK;
    ULONG i;
 
    TRACE("(%p,%u,%p,%p)\n", iface, ulValues, lpProps, lppProbs);
 
    if (!iface || !lpProps)
      return MAPI_E_INVALID_PARAMETER;
 
    for (i = 0; i < ulValues; i++)
    {
        if (FBadProp(&lpProps[i]) ||
            PROP_TYPE(lpProps[i].ulPropTag) == PT_OBJECT ||
            PROP_TYPE(lpProps[i].ulPropTag) == PT_NULL)
          return MAPI_E_INVALID_PARAMETER;
    }
 
    IMAPIPROP_Lock(This);
 
    /* FIXME: Under what circumstances is lpProbs created? */
    for (i = 0; i < ulValues; i++)
    {
        LPIPropDataItem item = IMAPIPROP_GetValue(This, lpProps[i].ulPropTag);
 
        if (item)
        {
            HRESULT hRetTmp;
            LPVOID lpMem = NULL;
 
            /* Found, so update the existing value */
            if (item->value->ulPropTag != lpProps[i].ulPropTag)
                FIXME("semi-stub, overwriting type (not coercing)\n");
 
            hRetTmp = This->lpAlloc(sizeof(SPropValue), &lpMem);
            if (SUCCEEDED(hRetTmp))
            {
                hRetTmp = PropCopyMore(lpMem, &lpProps[i], This->lpMore, lpMem);
                if (SUCCEEDED(hRetTmp))
                {
                    This->lpFree(item->value);
                    item->value = lpMem;
                    continue;
                }
                This->lpFree(lpMem);
            }
            hRet = hRetTmp;
        }
        else
        {
            /* Add new value */
            if (!IMAPIPROP_AddValue(This, &lpProps[i]))
                hRet = MAPI_E_NOT_ENOUGH_MEMORY;
        }
    }
 
    IMAPIPROP_Unlock(This);
    return hRet;
}

LPropCompareProp()

LONG WINAPI LPropCompareProp	(	LPSPropValue	lpPropLeft,
		LPSPropValue	lpPropRight
	)

Definition at line 441 of file prop.c.

{
    LONG iRet;
 
    TRACE("(%p->0x%08x,%p->0x%08x)\n", lpPropLeft, lpPropLeft->ulPropTag,
          lpPropRight, lpPropRight->ulPropTag);
 
    /* If the properties are not the same, sort by property type */
    if (PROP_TYPE(lpPropLeft->ulPropTag) != PROP_TYPE(lpPropRight->ulPropTag))
        return (LONG)PROP_TYPE(lpPropLeft->ulPropTag) - (LONG)PROP_TYPE(lpPropRight->ulPropTag);
 
    switch (PROP_TYPE(lpPropLeft->ulPropTag))
    {
    case PT_UNSPECIFIED:
    case PT_NULL:
        return 0; /* NULLs are equal */
    case PT_I2:
        return lpPropLeft->Value.i - lpPropRight->Value.i;
    case PT_I4:
        return lpPropLeft->Value.l - lpPropRight->Value.l;
    case PT_I8:
        if (lpPropLeft->Value.li.QuadPart > lpPropRight->Value.li.QuadPart)
            return 1;
        if (lpPropLeft->Value.li.QuadPart == lpPropRight->Value.li.QuadPart)
            return 0;
        return -1;
    case PT_R4:
        if (lpPropLeft->Value.flt > lpPropRight->Value.flt)
            return 1;
        if (lpPropLeft->Value.flt == lpPropRight->Value.flt)
            return 0;
        return -1;
    case PT_APPTIME:
    case PT_R8:
        if (lpPropLeft->Value.dbl > lpPropRight->Value.dbl)
            return 1;
        if (lpPropLeft->Value.dbl == lpPropRight->Value.dbl)
            return 0;
        return -1;
    case PT_CURRENCY:
        if (lpPropLeft->Value.cur.int64 > lpPropRight->Value.cur.int64)
            return 1;
        if (lpPropLeft->Value.cur.int64 == lpPropRight->Value.cur.int64)
            return 0;
        return -1;
    case PT_SYSTIME:
        return CompareFileTime(&lpPropLeft->Value.ft, &lpPropRight->Value.ft);
    case PT_BOOLEAN:
        return (lpPropLeft->Value.b ? 1 : 0) - (lpPropRight->Value.b ? 1 : 0);
    case PT_BINARY:
        if (lpPropLeft->Value.bin.cb == lpPropRight->Value.bin.cb)
            iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
                          lpPropLeft->Value.bin.cb);
        else
        {
            iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
                          min(lpPropLeft->Value.bin.cb, lpPropRight->Value.bin.cb));
 
            if (!iRet)
                iRet = lpPropLeft->Value.bin.cb - lpPropRight->Value.bin.cb;
        }
        return iRet;
    case PT_STRING8:
        return lstrcmpA(lpPropLeft->Value.lpszA, lpPropRight->Value.lpszA);
    case PT_UNICODE:
        return lstrcmpW(lpPropLeft->Value.lpszW, lpPropRight->Value.lpszW);
    case PT_ERROR:
        if (lpPropLeft->Value.err > lpPropRight->Value.err)
            return 1;
        if (lpPropLeft->Value.err == lpPropRight->Value.err)
            return 0;
        return -1;
    case PT_CLSID:
        return memcmp(lpPropLeft->Value.lpguid, lpPropRight->Value.lpguid,
                      sizeof(GUID));
    }
    FIXME("Unhandled property type %d\n", PROP_TYPE(lpPropLeft->ulPropTag));
    return 0;
}

Referenced by FPropCompareProp(), and FPropContainsProp().

LpValFindProp()

LPSPropValue WINAPI LpValFindProp	(	ULONG	ulPropTag,
		ULONG	cValues,
		LPSPropValue	lpProps
	)

Definition at line 1076 of file prop.c.

{
    TRACE("(%d,%d,%p)\n", ulPropTag, cValues, lpProps);
 
    if (lpProps && cValues)
    {
        ULONG i;
        for (i = 0; i < cValues; i++)
        {
            if (PROP_ID(ulPropTag) == PROP_ID(lpProps[i].ulPropTag))
                return &lpProps[i];
        }
    }
    return NULL;
}

PpropFindProp()

LPSPropValue WINAPI PpropFindProp	(	LPSPropValue	lpProps,
		ULONG	cValues,
		ULONG	ulPropTag
	)

Definition at line 639 of file prop.c.

{
    TRACE("(%p,%d,%d)\n", lpProps, cValues, ulPropTag);
 
    if (lpProps && cValues)
    {
        ULONG i;
        for (i = 0; i < cValues; i++)
        {
            if (!FBadPropTag(lpProps[i].ulPropTag) &&
                (lpProps[i].ulPropTag == ulPropTag ||
                 (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
                  PROP_ID(lpProps[i].ulPropTag) == PROP_ID(ulPropTag))))
                return &lpProps[i];
        }
    }
    return NULL;
}

PROP_BadArray()

static ULONG PROP_BadArray ( LPSPropValue  lpProp, size_t  elemSize  )

inlinestatic

Definition at line 39 of file prop.c.

{
    return IsBadReadPtr(lpProp->Value.MVi.lpi, lpProp->Value.MVi.cValues * elemSize);
}

Referenced by FBadProp().

PROP_IsBadAccess()

static BOOL PROP_IsBadAccess ( ULONG  ulAccess )

inlinestatic

Definition at line 2086 of file prop.c.

{
    switch (ulAccess)
    {
    case IPROP_READONLY|IPROP_CLEAN:
    case IPROP_READONLY|IPROP_DIRTY:
    case IPROP_READWRITE|IPROP_CLEAN:
    case IPROP_READWRITE|IPROP_DIRTY:
        return FALSE;
    }
    return TRUE;
}

Referenced by IPropData_fnHrSetPropAccess().

PropCopyMore()

SCODE WINAPI PropCopyMore	(	LPSPropValue	lpDest,
		LPSPropValue	lpSrc,
		ALLOCATEMORE *	lpMore,
		LPVOID	lpOrig
	)

Definition at line 64 of file prop.c.

{
    ULONG ulLen, i;
    SCODE scode = S_OK;
 
    TRACE("(%p,%p,%p,%p)\n", lpDest, lpSrc, lpMore, lpOrig);
 
    if (!lpDest || IsBadWritePtr(lpDest, sizeof(SPropValue)) ||
        FBadProp(lpSrc) || !lpMore)
        return MAPI_E_INVALID_PARAMETER;
 
    /* Shallow copy first, this is sufficient for properties without pointers */
    *lpDest = *lpSrc;
 
   switch (PROP_TYPE(lpSrc->ulPropTag))
    {
    case PT_CLSID:
        scode = lpMore(sizeof(GUID), lpOrig, (LPVOID*)&lpDest->Value.lpguid);
        if (SUCCEEDED(scode))
            *lpDest->Value.lpguid = *lpSrc->Value.lpguid;
        break;
    case PT_STRING8:
        ulLen = lstrlenA(lpSrc->Value.lpszA) + 1u;
        scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszA);
        if (SUCCEEDED(scode))
            memcpy(lpDest->Value.lpszA, lpSrc->Value.lpszA, ulLen);
        break;
    case PT_UNICODE:
        ulLen = (lstrlenW(lpSrc->Value.lpszW) + 1u) * sizeof(WCHAR);
        scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszW);
        if (SUCCEEDED(scode))
            memcpy(lpDest->Value.lpszW, lpSrc->Value.lpszW, ulLen);
        break;
    case PT_BINARY:
        scode = lpMore(lpSrc->Value.bin.cb, lpOrig, (LPVOID*)&lpDest->Value.bin.lpb);
        if (SUCCEEDED(scode))
            memcpy(lpDest->Value.bin.lpb, lpSrc->Value.bin.lpb, lpSrc->Value.bin.cb);
        break;
    default:
        if (lpSrc->ulPropTag & MV_FLAG)
        {
            ulLen = UlPropSize(lpSrc);
 
            if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_STRING8 ||
                PROP_TYPE(lpSrc->ulPropTag) == PT_MV_UNICODE)
            {
                /* UlPropSize doesn't account for the string pointers */
                ulLen += lpSrc->Value.MVszA.cValues * sizeof(char*);
            }
            else if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_BINARY)
            {
               /* UlPropSize doesn't account for the SBinary structs */
               ulLen += lpSrc->Value.MVbin.cValues * sizeof(SBinary);
            }
 
            lpDest->Value.MVi.cValues = lpSrc->Value.MVi.cValues;
            scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.MVi.lpi);
            if (FAILED(scode))
                break;
 
            /* Note that we could allocate the memory for each value in a
             * multi-value property separately, however if an allocation failed
             * we would be left with a bunch of allocated memory, which (while
             * not really leaked) is unusable until lpOrig is freed. So for
             * strings and binary arrays we make a single allocation for all
             * of the data. This is consistent since individual elements can't
             * be freed anyway.
             */
 
            switch (PROP_TYPE(lpSrc->ulPropTag))
            {
            case PT_MV_STRING8:
            {
                char *lpNextStr = (char*)(lpDest->Value.MVszA.lppszA +
                                          lpDest->Value.MVszA.cValues);
 
                for (i = 0; i < lpSrc->Value.MVszA.cValues; i++)
                {
                    ULONG ulStrLen = lstrlenA(lpSrc->Value.MVszA.lppszA[i]) + 1u;
 
                    lpDest->Value.MVszA.lppszA[i] = lpNextStr;
                    memcpy(lpNextStr, lpSrc->Value.MVszA.lppszA[i], ulStrLen);
                    lpNextStr += ulStrLen;
                }
                break;
            }
            case PT_MV_UNICODE:
            {
                WCHAR *lpNextStr = (WCHAR*)(lpDest->Value.MVszW.lppszW +
                                            lpDest->Value.MVszW.cValues);
 
                for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
                {
                    ULONG ulStrLen = lstrlenW(lpSrc->Value.MVszW.lppszW[i]) + 1u;
 
                    lpDest->Value.MVszW.lppszW[i] = lpNextStr;
                    memcpy(lpNextStr, lpSrc->Value.MVszW.lppszW[i], ulStrLen * sizeof(WCHAR));
                    lpNextStr += ulStrLen;
                }
                break;
            }
            case PT_MV_BINARY:
            {
                LPBYTE lpNext = (LPBYTE)(lpDest->Value.MVbin.lpbin +
                                         lpDest->Value.MVbin.cValues);
 
                for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
                {
                    lpDest->Value.MVbin.lpbin[i].cb = lpSrc->Value.MVbin.lpbin[i].cb;
                    lpDest->Value.MVbin.lpbin[i].lpb = lpNext;
                    memcpy(lpNext, lpSrc->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
                    lpNext += lpDest->Value.MVbin.lpbin[i].cb;
                }
                break;
            }
            default:
                /* No embedded pointers, just copy the data over */
                memcpy(lpDest->Value.MVi.lpi, lpSrc->Value.MVi.lpi, ulLen);
                break;
            }
            break;
        }
    }
    return scode;
}

Referenced by IMAPIPROP_AddValue(), IPropData_fnGetProps(), and IPropData_fnSetProps().

ScCopyProps()

SCODE WINAPI ScCopyProps	(	int	cValues,
		LPSPropValue	lpProps,
		LPVOID	lpDst,
		ULONG *	lpCount
	)

Definition at line 800 of file prop.c.

{
    LPSPropValue lpDest = (LPSPropValue)lpDst;
    char *lpDataDest = (char *)(lpDest + cValues);
    ULONG ulLen, i;
    int iter;
 
    TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpDst, lpCount);
 
    if (!lpProps || cValues < 0 || !lpDest)
        return MAPI_E_INVALID_PARAMETER;
 
    memcpy(lpDst, lpProps, cValues * sizeof(SPropValue));
 
    for (iter = 0; iter < cValues; iter++)
    {
        switch (PROP_TYPE(lpProps->ulPropTag))
        {
        case PT_CLSID:
            lpDest->Value.lpguid = (LPGUID)lpDataDest;
            *lpDest->Value.lpguid = *lpProps->Value.lpguid;
            lpDataDest += sizeof(GUID);
            break;
        case PT_STRING8:
            ulLen = lstrlenA(lpProps->Value.lpszA) + 1u;
            lpDest->Value.lpszA = lpDataDest;
            memcpy(lpDest->Value.lpszA, lpProps->Value.lpszA, ulLen);
            lpDataDest += ulLen;
            break;
        case PT_UNICODE:
            ulLen = (lstrlenW(lpProps->Value.lpszW) + 1u) * sizeof(WCHAR);
            lpDest->Value.lpszW = (LPWSTR)lpDataDest;
            memcpy(lpDest->Value.lpszW, lpProps->Value.lpszW, ulLen);
            lpDataDest += ulLen;
            break;
        case PT_BINARY:
            lpDest->Value.bin.lpb = (LPBYTE)lpDataDest;
            memcpy(lpDest->Value.bin.lpb, lpProps->Value.bin.lpb, lpProps->Value.bin.cb);
            lpDataDest += lpProps->Value.bin.cb;
            break;
        default:
            if (lpProps->ulPropTag & MV_FLAG)
            {
                lpDest->Value.MVi.cValues = lpProps->Value.MVi.cValues;
                /* Note: Assignment uses lppszA but covers all cases by union aliasing */
                lpDest->Value.MVszA.lppszA = (char**)lpDataDest;
 
                switch (PROP_TYPE(lpProps->ulPropTag))
                {
                case PT_MV_STRING8:
                {
                    lpDataDest += lpProps->Value.MVszA.cValues * sizeof(char *);
 
                    for (i = 0; i < lpProps->Value.MVszA.cValues; i++)
                    {
                        ULONG ulStrLen = lstrlenA(lpProps->Value.MVszA.lppszA[i]) + 1u;
 
                        lpDest->Value.MVszA.lppszA[i] = lpDataDest;
                        memcpy(lpDataDest, lpProps->Value.MVszA.lppszA[i], ulStrLen);
                        lpDataDest += ulStrLen;
                    }
                    break;
                }
                case PT_MV_UNICODE:
                {
                    lpDataDest += lpProps->Value.MVszW.cValues * sizeof(WCHAR *);
 
                    for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
                    {
                        ULONG ulStrLen = (lstrlenW(lpProps->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
 
                        lpDest->Value.MVszW.lppszW[i] = (LPWSTR)lpDataDest;
                        memcpy(lpDataDest, lpProps->Value.MVszW.lppszW[i], ulStrLen);
                        lpDataDest += ulStrLen;
                    }
                    break;
                }
                case PT_MV_BINARY:
                {
                    lpDataDest += lpProps->Value.MVszW.cValues * sizeof(SBinary);
 
                    for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
                    {
                        lpDest->Value.MVbin.lpbin[i].cb = lpProps->Value.MVbin.lpbin[i].cb;
                        lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)lpDataDest;
                        memcpy(lpDataDest, lpProps->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
                        lpDataDest += lpDest->Value.MVbin.lpbin[i].cb;
                    }
                    break;
                }
                default:
                    /* No embedded pointers, just copy the data over */
                    ulLen = UlPropSize(lpProps);
                    memcpy(lpDest->Value.MVi.lpi, lpProps->Value.MVi.lpi, ulLen);
                    lpDataDest += ulLen;
                    break;
                }
                break;
            }
        }
        lpDest++;
        lpProps++;
    }
    if (lpCount)
        *lpCount = lpDataDest - (char *)lpDst;
 
    return S_OK;
}

Referenced by ScDupPropset().

ScCountProps()

SCODE WINAPI ScCountProps	(	INT	iCount,
		LPSPropValue	lpProps,
		ULONG *	pcBytes
	)

Definition at line 719 of file prop.c.

{
    ULONG i, ulCount = iCount, ulBytes = 0;
 
    TRACE("(%d,%p,%p)\n", iCount, lpProps, pcBytes);
 
    if (iCount <= 0 || !lpProps ||
        IsBadReadPtr(lpProps, iCount * sizeof(SPropValue)))
        return MAPI_E_INVALID_PARAMETER;
 
    for (i = 0; i < ulCount; i++)
    {
        ULONG ulPropSize = 0;
 
        if (FBadProp(&lpProps[i]) || lpProps[i].ulPropTag == PROP_ID_NULL ||
            lpProps[i].ulPropTag == PROP_ID_INVALID)
            return MAPI_E_INVALID_PARAMETER;
 
        if (PROP_TYPE(lpProps[i].ulPropTag) != PT_OBJECT)
        {
            ulPropSize = UlPropSize(&lpProps[i]);
            if (!ulPropSize)
                return MAPI_E_INVALID_PARAMETER;
        }
 
        switch (PROP_TYPE(lpProps[i].ulPropTag))
        {
        case PT_STRING8:
        case PT_UNICODE:
        case PT_CLSID:
        case PT_BINARY:
        case PT_MV_I2:
        case PT_MV_I4:
        case PT_MV_I8:
        case PT_MV_R4:
        case PT_MV_R8:
        case PT_MV_CURRENCY:
        case PT_MV_SYSTIME:
        case PT_MV_APPTIME:
            ulPropSize += sizeof(SPropValue);
            break;
        case PT_MV_CLSID:
            ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue);
            break;
        case PT_MV_STRING8:
        case PT_MV_UNICODE:
            ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue);
            break;
        case PT_MV_BINARY:
            ulPropSize += lpProps[i].Value.MVbin.cValues * sizeof(SBinary) + sizeof(SPropValue);
            break;
        default:
            ulPropSize = sizeof(SPropValue);
            break;
        }
        ulBytes += ulPropSize;
    }
    if (pcBytes)
        *pcBytes = ulBytes;
 
    return S_OK;
}

Referenced by ScDupPropset().

ScDupPropset()

SCODE WINAPI ScDupPropset	(	int	cValues,
		LPSPropValue	lpProps,
		LPALLOCATEBUFFER	lpAlloc,
		LPSPropValue *	lpNewProp
	)

Definition at line 1108 of file prop.c.

{
    ULONG ulCount;
    SCODE sc;
 
    TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpAlloc, lpNewProp);
 
    sc = ScCountProps(cValues, lpProps, &ulCount);
    if (SUCCEEDED(sc))
    {
        sc = lpAlloc(ulCount, (LPVOID*)lpNewProp);
        if (SUCCEEDED(sc))
            sc = ScCopyProps(cValues, lpProps, *lpNewProp, &ulCount);
    }
    return sc;
}

ScRelocProps()

SCODE WINAPI ScRelocProps	(	int	cValues,
		LPSPropValue	lpProps,
		LPVOID	lpOld,
		LPVOID	lpNew,
		ULONG *	lpCount
	)

Definition at line 934 of file prop.c.

{
    static const BOOL bBadPtr = TRUE; /* Windows bug - Assumes source is bad */
    LPSPropValue lpDest = lpProps;
    ULONG ulCount = cValues * sizeof(SPropValue);
    ULONG ulLen, i;
    int iter;
 
    TRACE("(%d,%p,%p,%p,%p)\n", cValues, lpProps, lpOld, lpNew, lpCount);
 
    if (!lpProps || cValues < 0 || !lpOld || !lpNew)
        return MAPI_E_INVALID_PARAMETER;
 
    /* The reason native doesn't work as MSDN states is that it assumes that
     * the lpProps pointer contains valid pointers. This is obviously not
     * true if the array is being read back from serialisation (the pointers
     * are just offsets). Native can't actually work converting the pointers to
     * offsets either, because it converts any array pointers to offsets then
     * _dereferences the offset_ in order to convert the array elements!
     *
     * The code below would handle both cases except that the design of this
     * function makes it impossible to know when the pointers in lpProps are
     * valid. If both lpOld and lpNew are non-NULL, native reads the pointers
     * after converting them, so we must do the same. It seems this
     * functionality was never tested by MS.
     */
 
#define RELOC_PTR(p) (((char*)(p)) - (char*)lpOld + (char*)lpNew)
 
    for (iter = 0; iter < cValues; iter++)
    {
        switch (PROP_TYPE(lpDest->ulPropTag))
        {
        case PT_CLSID:
            lpDest->Value.lpguid = (LPGUID)RELOC_PTR(lpDest->Value.lpguid);
            ulCount += sizeof(GUID);
            break;
        case PT_STRING8:
            ulLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.lpszA) + 1u;
            lpDest->Value.lpszA = RELOC_PTR(lpDest->Value.lpszA);
            if (bBadPtr)
                ulLen = lstrlenA(lpDest->Value.lpszA) + 1u;
            ulCount += ulLen;
            break;
        case PT_UNICODE:
            ulLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
            lpDest->Value.lpszW = (LPWSTR)RELOC_PTR(lpDest->Value.lpszW);
            if (bBadPtr)
                ulLen = (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
            ulCount += ulLen;
            break;
        case PT_BINARY:
            lpDest->Value.bin.lpb = (LPBYTE)RELOC_PTR(lpDest->Value.bin.lpb);
            ulCount += lpDest->Value.bin.cb;
            break;
        default:
            if (lpDest->ulPropTag & MV_FLAG)
            {
                /* Since we have to access the array elements, don't map the
                 * array unless it is invalid (otherwise, map it at the end)
                 */
                if (bBadPtr)
                    lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
 
                switch (PROP_TYPE(lpProps->ulPropTag))
                {
                case PT_MV_STRING8:
                {
                    ulCount += lpDest->Value.MVszA.cValues * sizeof(char *);
 
                    for (i = 0; i < lpDest->Value.MVszA.cValues; i++)
                    {
                        ULONG ulStrLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
 
                        lpDest->Value.MVszA.lppszA[i] = RELOC_PTR(lpDest->Value.MVszA.lppszA[i]);
                        if (bBadPtr)
                            ulStrLen = lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
                        ulCount += ulStrLen;
                    }
                    break;
                }
                case PT_MV_UNICODE:
                {
                    ulCount += lpDest->Value.MVszW.cValues * sizeof(WCHAR *);
 
                    for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
                    {
                        ULONG ulStrLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
 
                        lpDest->Value.MVszW.lppszW[i] = (LPWSTR)RELOC_PTR(lpDest->Value.MVszW.lppszW[i]);
                        if (bBadPtr)
                            ulStrLen = (lstrlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
                        ulCount += ulStrLen;
                    }
                    break;
                }
                case PT_MV_BINARY:
                {
                    ulCount += lpDest->Value.MVszW.cValues * sizeof(SBinary);
 
                    for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
                    {
                        lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)RELOC_PTR(lpDest->Value.MVbin.lpbin[i].lpb);
                        ulCount += lpDest->Value.MVbin.lpbin[i].cb;
                    }
                    break;
                }
                default:
                    ulCount += UlPropSize(lpDest);
                    break;
                }
                if (!bBadPtr)
                    lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
                break;
            }
        }
        lpDest++;
    }
    if (lpCount)
        *lpCount = ulCount;
 
    return S_OK;
}

UlPropSize()

ULONG WINAPI UlPropSize

(

LPSPropValue

lpProp

)

Definition at line 213 of file prop.c.

{
    ULONG ulRet = 1u, i;
 
    TRACE("(%p)\n", lpProp);
 
    switch (PROP_TYPE(lpProp->ulPropTag))
    {
    case PT_MV_I2:       ulRet = lpProp->Value.MVi.cValues;
                         /* fall through */
    case PT_BOOLEAN:
    case PT_I2:          ulRet *= sizeof(USHORT);
                         break;
    case PT_MV_I4:       ulRet = lpProp->Value.MVl.cValues;
                         /* fall through */
    case PT_ERROR:
    case PT_I4:          ulRet *= sizeof(LONG);
                         break;
    case PT_MV_I8:       ulRet = lpProp->Value.MVli.cValues;
                         /* fall through */
    case PT_I8:          ulRet *= sizeof(LONG64);
                         break;
    case PT_MV_R4:       ulRet = lpProp->Value.MVflt.cValues;
                         /* fall through */
    case PT_R4:          ulRet *= sizeof(float);
                         break;
    case PT_MV_APPTIME:
    case PT_MV_R8:       ulRet = lpProp->Value.MVdbl.cValues;
                         /* fall through */
    case PT_APPTIME:
    case PT_R8:          ulRet *= sizeof(double);
                         break;
    case PT_MV_CURRENCY: ulRet = lpProp->Value.MVcur.cValues;
                         /* fall through */
    case PT_CURRENCY:    ulRet *= sizeof(CY);
                         break;
    case PT_MV_SYSTIME:  ulRet = lpProp->Value.MVft.cValues;
                         /* fall through */
    case PT_SYSTIME:     ulRet *= sizeof(FILETIME);
                         break;
    case PT_MV_CLSID:    ulRet = lpProp->Value.MVguid.cValues;
                         /* fall through */
    case PT_CLSID:       ulRet *= sizeof(GUID);
                         break;
    case PT_MV_STRING8:  ulRet = 0u;
                         for (i = 0; i < lpProp->Value.MVszA.cValues; i++)
                             ulRet += (lstrlenA(lpProp->Value.MVszA.lppszA[i]) + 1u);
                         break;
    case PT_STRING8:     ulRet = lstrlenA(lpProp->Value.lpszA) + 1u;
                         break;
    case PT_MV_UNICODE:  ulRet = 0u;
                         for (i = 0; i < lpProp->Value.MVszW.cValues; i++)
                             ulRet += (lstrlenW(lpProp->Value.MVszW.lppszW[i]) + 1u);
                         ulRet *= sizeof(WCHAR);
                         break;
    case PT_UNICODE:     ulRet = (lstrlenW(lpProp->Value.lpszW) + 1u) * sizeof(WCHAR);
                         break;
    case PT_MV_BINARY:   ulRet = 0u;
                         for (i = 0; i < lpProp->Value.MVbin.cValues; i++)
                             ulRet += lpProp->Value.MVbin.lpbin[i].cb;
                         break;
    case PT_BINARY:      ulRet = lpProp->Value.bin.cb;
                         break;
    case PT_OBJECT:
    default:             ulRet = 0u;
                         break;
    }
 
    return ulRet;
}

Referenced by PropCopyMore(), ScCopyProps(), ScCountProps(), and ScRelocProps().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mapi

)

Variable Documentation

IPropDataImpl_vtbl

const IPropDataVtbl IPropDataImpl_vtbl

static

Initial value:

=
{
    IPropData_fnQueryInterface,
    IPropData_fnAddRef,
    IPropData_fnRelease,
    IPropData_fnGetLastError,
    IPropData_fnSaveChanges,
    IPropData_fnGetProps,
    IPropData_fnGetPropList,
    IPropData_fnOpenProperty,
    IPropData_fnSetProps,
    IPropData_fnDeleteProps,
    IPropData_fnCopyTo,
    IPropData_fnCopyProps,
    IPropData_fnGetNamesFromIDs,
    IPropData_fnGetIDsFromNames,
    IPropData_fnHrSetObjAccess,
    IPropData_fnHrSetPropAccess,
    IPropData_fnHrGetPropAccess,
    IPropData_fnHrAddObjProps
}

Definition at line 2267 of file prop.c.

Referenced by CreateIProp().