mapiutil.h File Reference

#include <mapix.h>

Include dependency graph for mapiutil.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	TAD_ALL_ROWS   1 /* Delete all rows */
#define	SOF_UNIQUEFILENAME   0x80000000U /* Create a unique (temporary) filename */
#define	OPENSTREAMONFILE   "OpenStreamOnFile"
#define	IPROP_READONLY   0x00001U
#define	IPROP_READWRITE   0x00002U
#define	IPROP_CLEAN   0x10000U
#define	IPROP_DIRTY   0x20000U
#define	szHrDispatchNotifications   "_HrDispatchNotifications@4"
#define	szScCreateConversationIndex   "_ScCreateConversationIndex@16"
#define	INTERFACE   ITableData
#define	ITableData_QueryInterface(p, a, b)   (p)->lpVtbl->QueryInterface(p,a,b)
#define	ITableData_AddRef(p)   (p)->lpVtbl->AddRef(p)
#define	ITableData_Release(p)   (p)->lpVtbl->Release(p)
#define	ITableData_HrGetView(p, a, b, c, d)   (p)->lpVtbl->HrGetView(p,a,b,c,d)
#define	ITableData_HrModifyRow(p, a)   (p)->lpVtbl->HrModifyRow(p,a)
#define	ITableData_HrDeleteRow(p, a)   (p)->lpVtbl->HrDeleteRow(p,a)
#define	ITableData_HrQueryRow(p, a, b, c)   (p)->lpVtbl->HrQueryRow(p,a,b,c)
#define	ITableData_HrEnumRow(p, a, b)   (p)->lpVtbl->HrEnumRow(p,a,b)
#define	ITableData_HrNotify(p, a, b, c)   (p)->lpVtbl->HrNotify(p,a,b,c)
#define	ITableData_HrInsertRow(p, a, b)   (p)->lpVtbl->HrInsertRow(p,a,b)
#define	ITableData_HrModifyRows(p, a, b)   (p)->lpVtbl->HrModifyRows(p,a,b)
#define	ITableData_HrDeleteRows(p, a, b, c)   (p)->lpVtbl->HrDeleteRows(p,a,b,c)
#define	INTERFACE   IPropData
#define	IPropData_QueryInterface(p, a, b)   (p)->lpVtbl->QueryInterface(p,a,b)
#define	IPropData_AddRef(p)   (p)->lpVtbl->AddRef(p)
#define	IPropData_Release(p)   (p)->lpVtbl->Release(p)
#define	IPropData_GetLastError(p, a, b, c)   (p)->lpVtbl->GetLastError(p,a,b,c)
#define	IPropData_SaveChanges(p, a)   (p)->lpVtbl->SaveChanges(p,a)
#define	IPropData_GetProps(p, a, b, c, d)   (p)->lpVtbl->GetProps(p,a,b,c,d)
#define	IPropData_GetPropList(p, a, b)   (p)->lpVtbl->GetPropList(p,a,b)
#define	IPropData_OpenProperty(p, a, b, c, d, e)   (p)->lpVtbl->OpenProperty(p,a,b,c,d,e)
#define	IPropData_SetProps(p, a, b, c)   (p)->lpVtbl->SetProps(p,a,b,c)
#define	IPropData_DeleteProps(p, a, b)   (p)->lpVtbl->DeleteProps(p,a,b)
#define	IPropData_CopyTo(p, a, b, c, d, e, f, g, h, i)   (p)->lpVtbl->CopyTo(p,a,b,c,d,e,f,g,h,i)
#define	IPropData_CopyProps(p, a, b, c, d, e, f, g)   (p)->lpVtbl->CopyProps(p,a,b,c,d,e,f,g)
#define	IPropData_GetNamesFromIDs(p, a, b, c, d, e)   (p)->lpVtbl->GetNamesFromIDs(p,a,b,c,d,e)
#define	IPropData_GetIDsFromNames(p, a, b, c, d)   (p)->lpVtbl->GetIDsFromNames(p,a,b,c,d)
#define	IPropData_HrSetObjAccess(p, a)   (p)->lpVtbl->HrSetObjAccess(p,a)
#define	IPropData_HrSetPropAccess(p, a, b)   (p)->lpVtbl->HrSetPropAccess(p,a,b)
#define	IPropData_HrGetPropAccess(p, a, b)   (p)->lpVtbl->HrGetPropAccess(p,a,b)
#define	IPropData_HrAddObjProps(p, a, b)   (p)->lpVtbl->HrAddObjProps(p,a,b)

Typedefs
typedef HRESULT(WINAPI *	LPOPENSTREAMONFILE) (LPALLOCATEBUFFER, LPFREEBUFFER, ULONG, LPSTR, LPSTR, LPSTREAM *)
typedef struct IPropData *	LPPROPDATA
typedef DISPATCHNOTIFICATIONS *	LPDISPATCHNOTIFICATIONS
typedef ULONG LPBYTE *typedef CREATECONVERSATIONINDEX *	LPCREATECONVERSATIONINDEX
typedef struct ITableData *	LPTABLEDATA

Functions
LPMALLOC WINAPI	MAPIGetDefaultMalloc (void)
HRESULT WINAPI	OpenStreamOnFile (LPALLOCATEBUFFER, LPFREEBUFFER, ULONG, LPSTR, LPSTR, LPSTREAM *)
BOOL WINAPI	FEqualNames (LPMAPINAMEID, LPMAPINAMEID)
SCODE WINAPI	CreateIProp (LPCIID, ALLOCATEBUFFER *, ALLOCATEMORE *, FREEBUFFER *, LPVOID, LPPROPDATA *)
SCODE WINAPI	PropCopyMore (LPSPropValue, LPSPropValue, ALLOCATEMORE *, LPVOID)
ULONG WINAPI	UlPropSize (LPSPropValue)
VOID WINAPI	GetInstance (LPSPropValue, LPSPropValue, ULONG)
BOOL WINAPI	FPropContainsProp (LPSPropValue, LPSPropValue, ULONG)
BOOL WINAPI	FPropCompareProp (LPSPropValue, ULONG, LPSPropValue)
LONG WINAPI	LPropCompareProp (LPSPropValue, LPSPropValue)
HRESULT WINAPI	HrAddColumns (LPMAPITABLE, LPSPropTagArray, LPALLOCATEBUFFER, LPFREEBUFFER)
HRESULT WINAPI	HrAddColumnsEx (LPMAPITABLE, LPSPropTagArray, LPALLOCATEBUFFER, LPFREEBUFFER, void(*)(LPSPropTagArray))
HRESULT WINAPI	HrAllocAdviseSink (LPNOTIFCALLBACK, LPVOID, LPMAPIADVISESINK *)
HRESULT WINAPI	HrThisThreadAdviseSink (LPMAPIADVISESINK, LPMAPIADVISESINK *)
HRESULT WINAPI	HrDispatchNotifications (ULONG)
ULONG WINAPI	UlAddRef (void *)
ULONG WINAPI	UlRelease (void *)
HRESULT WINAPI	HrGetOneProp (LPMAPIPROP, ULONG, LPSPropValue *)
HRESULT WINAPI	HrSetOneProp (LPMAPIPROP, LPSPropValue)
BOOL WINAPI	FPropExists (LPMAPIPROP, ULONG)
void WINAPI	FreePadrlist (LPADRLIST)
void WINAPI	FreeProws (LPSRowSet)
HRESULT WINAPI	HrQueryAllRows (LPMAPITABLE, LPSPropTagArray, LPSRestriction, LPSSortOrderSet, LONG, LPSRowSet *)
LPSPropValue WINAPI	PpropFindProp (LPSPropValue, ULONG, ULONG)
BOOL WINAPI	FBinFromHex (LPSTR, LPBYTE)
SCODE WINAPI	ScBinFromHexBounded (LPSTR, LPBYTE, ULONG)
void WINAPI	HexFromBin (LPBYTE, int, LPSTR)
ULONG WINAPI	UlFromSzHex (LPCSTR)
LPSTR WINAPI	SzFindCh (LPCSTR, USHORT)
LPSTR WINAPI	SzFindLastCh (LPCSTR, USHORT)
LPSTR WINAPI	SzFindSz (LPCSTR, LPCSTR)
UINT WINAPI	UFromSz (LPCSTR)
SCODE WINAPI	ScInitMapiUtil (ULONG)
void WINAPI	DeinitMapiUtil (void)
typedef	HRESULT (WINAPI DISPATCHNOTIFICATIONS)(ULONG)
typedef	SCODE (WINAPI CREATECONVERSATIONINDEX)(ULONG
typedef	void (WINAPI CALLERRELEASE)(ULONG
	DECLARE_INTERFACE_ (ITableData, IUnknown)
SCODE WINAPI	CreateTable (LPCIID, ALLOCATEBUFFER *, ALLOCATEMORE *, FREEBUFFER *, LPVOID, ULONG, ULONG, LPSPropTagArray, LPTABLEDATA *)
SCODE WINAPI	ScCountNotifications (int, LPNOTIFICATION, ULONG *)
SCODE WINAPI	ScCountProps (int, LPSPropValue, ULONG *)
SCODE WINAPI	ScCopyNotifications (int, LPNOTIFICATION, LPVOID, ULONG *)
SCODE WINAPI	ScCopyProps (int, LPSPropValue, LPVOID, ULONG *)
SCODE WINAPI	ScDupPropset (int, LPSPropValue, LPALLOCATEBUFFER, LPSPropValue *)
SCODE WINAPI	ScRelocNotifications (int, LPNOTIFICATION, LPVOID, LPVOID, ULONG *)
SCODE WINAPI	ScRelocProps (int, LPSPropValue, LPVOID, LPVOID, ULONG *)
LPSPropValue WINAPI	LpValFindProp (ULONG, ULONG, LPSPropValue)
static FILETIME	FtAddFt (FILETIME ftLeft, FILETIME ftRight)
static FILETIME	FtSubFt (FILETIME ftLeft, FILETIME ftRight)
static FILETIME	FtNegFt (FILETIME ftLeft)
static FILETIME	FtMulDw (DWORD dwLeft, FILETIME ftRight)
static FILETIME	FtMulDwDw (DWORD dwLeft, DWORD dwRight)
	DECLARE_INTERFACE_ (IPropData, IMAPIProp)

Variables
typedef	LPBYTE
typedef	LPMAPITABLE

Macro Definition Documentation

INTERFACE [1/2]

#define INTERFACE   ITableData

Definition at line 219 of file mapiutil.h.

INTERFACE [2/2]

#define INTERFACE   IPropData

Definition at line 219 of file mapiutil.h.

IPROP_CLEAN

#define IPROP_CLEAN   0x10000U

Definition at line 53 of file mapiutil.h.

IPROP_DIRTY

#define IPROP_DIRTY   0x20000U

Definition at line 54 of file mapiutil.h.

IPROP_READONLY

#define IPROP_READONLY   0x00001U

Definition at line 51 of file mapiutil.h.

IPROP_READWRITE

#define IPROP_READWRITE   0x00002U

Definition at line 52 of file mapiutil.h.

IPropData_AddRef

#define IPropData_AddRef

(

p

)

(p)->lpVtbl->AddRef(p)

Definition at line 253 of file mapiutil.h.

IPropData_CopyProps

#define IPropData_CopyProps	(		p,
			a,
			b,
			c,
			d,
			e,
			f,
			g
	)		(p)->lpVtbl->CopyProps(p,a,b,c,d,e,f,g)

Definition at line 264 of file mapiutil.h.

IPropData_CopyTo

#define IPropData_CopyTo	(		p,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			i
	)		(p)->lpVtbl->CopyTo(p,a,b,c,d,e,f,g,h,i)

Definition at line 263 of file mapiutil.h.

IPropData_DeleteProps

#define IPropData_DeleteProps	(		p,
			a,
			b
	)		(p)->lpVtbl->DeleteProps(p,a,b)

Definition at line 262 of file mapiutil.h.

IPropData_GetIDsFromNames

#define IPropData_GetIDsFromNames	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->GetIDsFromNames(p,a,b,c,d)

Definition at line 266 of file mapiutil.h.

IPropData_GetLastError

#define IPropData_GetLastError	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->GetLastError(p,a,b,c)

Definition at line 256 of file mapiutil.h.

IPropData_GetNamesFromIDs

#define IPropData_GetNamesFromIDs	(		p,
			a,
			b,
			c,
			d,
			e
	)		(p)->lpVtbl->GetNamesFromIDs(p,a,b,c,d,e)

Definition at line 265 of file mapiutil.h.

IPropData_GetPropList

#define IPropData_GetPropList	(		p,
			a,
			b
	)		(p)->lpVtbl->GetPropList(p,a,b)

Definition at line 259 of file mapiutil.h.

IPropData_GetProps

#define IPropData_GetProps	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->GetProps(p,a,b,c,d)

Definition at line 258 of file mapiutil.h.

IPropData_HrAddObjProps

#define IPropData_HrAddObjProps	(		p,
			a,
			b
	)		(p)->lpVtbl->HrAddObjProps(p,a,b)

Definition at line 270 of file mapiutil.h.

IPropData_HrGetPropAccess

#define IPropData_HrGetPropAccess	(		p,
			a,
			b
	)		(p)->lpVtbl->HrGetPropAccess(p,a,b)

Definition at line 269 of file mapiutil.h.

IPropData_HrSetObjAccess

#define IPropData_HrSetObjAccess	(		p,
			a
	)		(p)->lpVtbl->HrSetObjAccess(p,a)

Definition at line 267 of file mapiutil.h.

IPropData_HrSetPropAccess

#define IPropData_HrSetPropAccess	(		p,
			a,
			b
	)		(p)->lpVtbl->HrSetPropAccess(p,a,b)

Definition at line 268 of file mapiutil.h.

IPropData_OpenProperty

#define IPropData_OpenProperty	(		p,
			a,
			b,
			c,
			d,
			e
	)		(p)->lpVtbl->OpenProperty(p,a,b,c,d,e)

Definition at line 260 of file mapiutil.h.

IPropData_QueryInterface

#define IPropData_QueryInterface	(		p,
			a,
			b
	)		(p)->lpVtbl->QueryInterface(p,a,b)

Definition at line 252 of file mapiutil.h.

IPropData_Release

#define IPropData_Release

(

p

)

(p)->lpVtbl->Release(p)

Definition at line 254 of file mapiutil.h.

IPropData_SaveChanges

#define IPropData_SaveChanges	(		p,
			a
	)		(p)->lpVtbl->SaveChanges(p,a)

Definition at line 257 of file mapiutil.h.

IPropData_SetProps

#define IPropData_SetProps	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetProps(p,a,b,c)

Definition at line 261 of file mapiutil.h.

ITableData_AddRef

#define ITableData_AddRef

(

p

)

(p)->lpVtbl->AddRef(p)

Definition at line 148 of file mapiutil.h.

ITableData_HrDeleteRow

#define ITableData_HrDeleteRow	(		p,
			a
	)		(p)->lpVtbl->HrDeleteRow(p,a)

Definition at line 153 of file mapiutil.h.

ITableData_HrDeleteRows

#define ITableData_HrDeleteRows	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->HrDeleteRows(p,a,b,c)

Definition at line 159 of file mapiutil.h.

ITableData_HrEnumRow

#define ITableData_HrEnumRow	(		p,
			a,
			b
	)		(p)->lpVtbl->HrEnumRow(p,a,b)

Definition at line 155 of file mapiutil.h.

ITableData_HrGetView

#define ITableData_HrGetView	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->HrGetView(p,a,b,c,d)

Definition at line 151 of file mapiutil.h.

ITableData_HrInsertRow

#define ITableData_HrInsertRow	(		p,
			a,
			b
	)		(p)->lpVtbl->HrInsertRow(p,a,b)

Definition at line 157 of file mapiutil.h.

ITableData_HrModifyRow

#define ITableData_HrModifyRow	(		p,
			a
	)		(p)->lpVtbl->HrModifyRow(p,a)

Definition at line 152 of file mapiutil.h.

ITableData_HrModifyRows

#define ITableData_HrModifyRows	(		p,
			a,
			b
	)		(p)->lpVtbl->HrModifyRows(p,a,b)

Definition at line 158 of file mapiutil.h.

ITableData_HrNotify

#define ITableData_HrNotify	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->HrNotify(p,a,b,c)

Definition at line 156 of file mapiutil.h.

ITableData_HrQueryRow

#define ITableData_HrQueryRow	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->HrQueryRow(p,a,b,c)

Definition at line 154 of file mapiutil.h.

ITableData_QueryInterface

#define ITableData_QueryInterface	(		p,
			a,
			b
	)		(p)->lpVtbl->QueryInterface(p,a,b)

Definition at line 147 of file mapiutil.h.

ITableData_Release

#define ITableData_Release

(

p

)

(p)->lpVtbl->Release(p)

Definition at line 149 of file mapiutil.h.

OPENSTREAMONFILE

#define OPENSTREAMONFILE   "OpenStreamOnFile"

Definition at line 45 of file mapiutil.h.

SOF_UNIQUEFILENAME

#define SOF_UNIQUEFILENAME   0x80000000U /* Create a unique (temporary) filename */

Definition at line 32 of file mapiutil.h.

szHrDispatchNotifications

#define szHrDispatchNotifications   "_HrDispatchNotifications@4"

Definition at line 107 of file mapiutil.h.

szScCreateConversationIndex

#define szScCreateConversationIndex   "_ScCreateConversationIndex@16"

Definition at line 108 of file mapiutil.h.

TAD_ALL_ROWS

#define TAD_ALL_ROWS   1 /* Delete all rows */

Definition at line 28 of file mapiutil.h.

Typedef Documentation

LPCREATECONVERSATIONINDEX

typedef ULONG LPBYTE* typedef CREATECONVERSATIONINDEX* LPCREATECONVERSATIONINDEX

Definition at line 113 of file mapiutil.h.

LPDISPATCHNOTIFICATIONS

typedef DISPATCHNOTIFICATIONS* LPDISPATCHNOTIFICATIONS

Definition at line 111 of file mapiutil.h.

LPOPENSTREAMONFILE

typedef HRESULT(WINAPI * LPOPENSTREAMONFILE) (LPALLOCATEBUFFER, LPFREEBUFFER, ULONG, LPSTR, LPSTR, LPSTREAM *)

Definition at line 40 of file mapiutil.h.

LPPROPDATA

typedef struct IPropData* LPPROPDATA

Definition at line 49 of file mapiutil.h.

LPTABLEDATA

typedef LPTABLEDATA

Definition at line 115 of file mapiutil.h.

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;
}

CreateTable()

SCODE WINAPI CreateTable	(	LPCIID	,
		ALLOCATEBUFFER *	,
		ALLOCATEMORE *	,
		FREEBUFFER *	,
		LPVOID	,
		ULONG	,
		ULONG	,
		LPSPropTagArray	,
		LPTABLEDATA *
	)

DECLARE_INTERFACE_() [1/2]

DECLARE_INTERFACE_	(	IPropData	,
		IMAPIProp
	)

Definition at line 220 of file mapiutil.h.

{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IMAPIProp methods ***/
    STDMETHOD(GetLastError)(THIS_ HRESULT hRes, ULONG ulFlags, LPMAPIERROR *lppErr) PURE;
    STDMETHOD(SaveChanges)(THIS_ ULONG ulFlags) PURE;
    STDMETHOD(GetProps)(THIS_ LPSPropTagArray lpPropTags, ULONG ulFlags, ULONG *lpValues, LPSPropValue *lppProps) PURE;
    STDMETHOD(GetPropList)(THIS_ ULONG  ulFlags, LPSPropTagArray *lppPropTagArray) PURE;
    STDMETHOD(OpenProperty)(THIS_ ULONG ulPropTag, LPCIID lpIid, ULONG ulOpts, ULONG ulFlags, LPUNKNOWN *lppUnk) PURE;
    STDMETHOD(SetProps)(THIS_ ULONG cValues, LPSPropValue lpProps, LPSPropProblemArray *lppProbs) PURE;
    STDMETHOD(DeleteProps)(THIS_ LPSPropTagArray lpPropTags, LPSPropProblemArray *lppProbs) PURE;
    STDMETHOD(CopyTo)(THIS_ ULONG ciidExclude, LPCIID lpIid, LPSPropTagArray lpProps, ULONG ulParam,
                      LPMAPIPROGRESS lpProgress, LPCIID lpIface,LPVOID lpDest, ULONG ulFlags,
                      LPSPropProblemArray *lppProbs) PURE;
    STDMETHOD(CopyProps)(THIS_ LPSPropTagArray lpIncludeProps, ULONG ulParam, LPMAPIPROGRESS lpProgress,
                         LPCIID lpIid, LPVOID lpDestObj, ULONG ulFlags, LPSPropProblemArray *lppProblems) PURE;
    STDMETHOD(GetNamesFromIDs)(THIS_ LPSPropTagArray *lppPropTags, LPGUID lpIid, ULONG ulFlags, ULONG *lpCount,
                               LPMAPINAMEID **lpppNames) PURE;
    STDMETHOD(GetIDsFromNames)(THIS_ ULONG cPropNames, LPMAPINAMEID *lppNames, ULONG ulFlags, LPSPropTagArray *lppPropTags) PURE;
    /*** IPropData methods ***/
    STDMETHOD(HrSetObjAccess)(THIS_ ULONG ulAccess) PURE;
    STDMETHOD(HrSetPropAccess)(THIS_ LPSPropTagArray lpPropTags, ULONG *lpAccess) PURE;
    STDMETHOD(HrGetPropAccess)(THIS_ LPSPropTagArray *lppPropTags, ULONG **lppAccess) PURE;
    STDMETHOD(HrAddObjProps)(THIS_ LPSPropTagArray lppPropTags, LPSPropProblemArray *lppProbs) PURE;
};

DECLARE_INTERFACE_() [2/2]

DECLARE_INTERFACE_	(	ITableData	,
		IUnknown
	)

Definition at line 125 of file mapiutil.h.

{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** ITableData methods ***/
    STDMETHOD(HrGetView)(THIS_ LPSSortOrderSet lpSort, CALLERRELEASE *lpRel,
                         ULONG ulData, LPMAPITABLE *lppTable) PURE;
    STDMETHOD(HrModifyRow)(THIS_ LPSRow lpRow) PURE;
    STDMETHOD(HrDeleteRow)(THIS_ LPSPropValue lpKey) PURE;
    STDMETHOD(HrQueryRow)(THIS_ LPSPropValue lpKey, LPSRow *lppRow, ULONG *lpRowNum) PURE;
    STDMETHOD(HrEnumRow)(THIS_ ULONG ulRowNum, LPSRow *lppRow) PURE;
    STDMETHOD(HrNotify)(THIS_ ULONG ulFlags, ULONG cValues, LPSPropValue lpValues) PURE;
    STDMETHOD(HrInsertRow)(THIS_ ULONG ulRow, LPSRow lpRow) PURE;
    STDMETHOD(HrModifyRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows) PURE;
    STDMETHOD(HrDeleteRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows, ULONG *lpCount) PURE;
};

DeinitMapiUtil()

void WINAPI DeinitMapiUtil

(

void

)

Definition at line 93 of file util.c.

{
    if (mapiFunctions.DeinitMapiUtil)
        mapiFunctions.DeinitMapiUtil();
    else
        FIXME("()stub!\n");
}

FBinFromHex()

BOOL WINAPI FBinFromHex	(	LPSTR	,
		LPBYTE
	)

FEqualNames()

BOOL WINAPI FEqualNames	(	LPMAPINAMEID	lpName1,
		LPMAPINAMEID	lpName2
	)

Definition at line 486 of file util.c.

{
    TRACE("(%p,%p)\n", lpName1, lpName2);
 
    if (!lpName1 || !lpName2 ||
        !IsEqualGUID(lpName1->lpguid, lpName2->lpguid) ||
        lpName1->ulKind != lpName2->ulKind)
        return FALSE;
 
    if (lpName1->ulKind == MNID_STRING)
        return !lstrcmpW(lpName1->Kind.lpwstrName, lpName2->Kind.lpwstrName);
 
    return lpName1->Kind.lID == lpName2->Kind.lID;
}

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().

FtAddFt()

static FILETIME FtAddFt ( FILETIME  ftLeft, FILETIME  ftRight  )

inlinestatic

Definition at line 175 of file mapiutil.h.

{
    LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight;
    union { FILETIME ft; LONG64 ll; } ftmap;
    ftmap.ll = *pl + *pr;
    return ftmap.ft;
}

FtMulDw()

static FILETIME FtMulDw ( DWORD  dwLeft, FILETIME  ftRight  )

inlinestatic

Definition at line 199 of file mapiutil.h.

{
    LONG64 l = (LONG64)dwLeft, *pr = (LONG64*)&ftRight;
    union { FILETIME ft; LONG64 ll; } ftmap;
    ftmap.ll = l * (*pr);
    return ftmap.ft;
}

FtMulDwDw()

static FILETIME FtMulDwDw ( DWORD  dwLeft, DWORD  dwRight  )

inlinestatic

Definition at line 207 of file mapiutil.h.

{
    LONG64 l = (LONG64)dwLeft, r = (LONG64)dwRight;
    union { FILETIME ft; LONG64 ll; } ftmap;
    ftmap.ll = l * r;
    return ftmap.ft;
}

FtNegFt()

static FILETIME FtNegFt ( FILETIME  ftLeft )

inlinestatic

Definition at line 191 of file mapiutil.h.

{
    LONG64 *p = (LONG64*)&ftLeft;
    union { FILETIME ft; LONG64 ll; } ftmap;
    ftmap.ll = -*p;
    return ftmap.ft;
}

FtSubFt()

static FILETIME FtSubFt ( FILETIME  ftLeft, FILETIME  ftRight  )

inlinestatic

Definition at line 183 of file mapiutil.h.

{
    LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight;
    union { FILETIME ft; LONG64 ll; } ftmap;
    ftmap.ll = *pl - *pr;
    return ftmap.ft;
}

GetInstance()

VOID WINAPI GetInstance	(	LPSPropValue	,
		LPSPropValue	,
		ULONG
	)

HexFromBin()

void WINAPI HexFromBin	(	LPBYTE	,
		int	,
		LPSTR
	)

HrAddColumns()

HRESULT WINAPI HrAddColumns	(	LPMAPITABLE	,
		LPSPropTagArray	,
		LPALLOCATEBUFFER	,
		LPFREEBUFFER
	)

HrAddColumnsEx()

HRESULT WINAPI HrAddColumnsEx	(	LPMAPITABLE	,
		LPSPropTagArray	,
		LPALLOCATEBUFFER	,
		LPFREEBUFFER	,
		void(*)(LPSPropTagArray)
	)

HrAllocAdviseSink()

HRESULT WINAPI HrAllocAdviseSink	(	LPNOTIFCALLBACK	,
		LPVOID	,
		LPMAPIADVISESINK *
	)

HrDispatchNotifications()

HRESULT WINAPI HrDispatchNotifications

(

ULONG

flags

)

Definition at line 243 of file util.c.

{
    FIXME("(%08x)\n", flags);
    return S_OK;
}

HRESULT()

typedef HRESULT

(

WINAPI

DISPATCHNOTIFICATIONS

)

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;
}

HrQueryAllRows()

HRESULT WINAPI HrQueryAllRows	(	LPMAPITABLE	lpTable,
		LPSPropTagArray	lpPropTags,
		LPSRestriction	lpRestriction,
		LPSSortOrderSet	lpSortOrderSet,
		LONG	crowsMax,
		LPSRowSet *	lppRows
	)

Definition at line 933 of file util.c.

{
    if (mapiFunctions.HrQueryAllRows)
        return mapiFunctions.HrQueryAllRows(lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
 
    FIXME("(%p, %p, %p, %p, %d, %p): stub\n", lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
    *lppRows = NULL;
    return MAPI_E_CALL_FAILED;
}

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);
}

HrThisThreadAdviseSink()

HRESULT WINAPI HrThisThreadAdviseSink	(	LPMAPIADVISESINK	lpSink,
		LPMAPIADVISESINK *	lppNewSink
	)

Definition at line 262 of file util.c.

{
    if (mapiFunctions.HrThisThreadAdviseSink)
        return mapiFunctions.HrThisThreadAdviseSink(lpSink, lppNewSink);
 
    FIXME("(%p,%p)semi-stub\n", lpSink, lppNewSink);
 
    if (!lpSink || !lppNewSink)
        return E_INVALIDARG;
 
    /* Don't wrap the sink for now, just copy it */
    *lppNewSink = lpSink;
    IMAPIAdviseSink_AddRef(lpSink);
    return S_OK;
}

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;
}

MAPIGetDefaultMalloc()

LPMALLOC WINAPI MAPIGetDefaultMalloc

(

void

)

Definition at line 62 of file imalloc.c.

{
    TRACE("()\n");
 
    if (mapiFunctions.MAPIGetDefaultMalloc)
        return mapiFunctions.MAPIGetDefaultMalloc();
 
    IMalloc_AddRef(&MAPI_IMalloc.IMalloc_iface);
    return &MAPI_IMalloc.IMalloc_iface;
}

OpenStreamOnFile()

HRESULT WINAPI OpenStreamOnFile	(	LPALLOCATEBUFFER	,
		LPFREEBUFFER	,
		ULONG	,
		LPSTR	,
		LPSTR	,
		LPSTREAM *
	)

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;
}

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().

ScBinFromHexBounded()

SCODE WINAPI ScBinFromHexBounded	(	LPSTR	,
		LPBYTE	,
		ULONG
	)

ScCopyNotifications()

SCODE WINAPI ScCopyNotifications	(	int	,
		LPNOTIFICATION	,
		LPVOID	,
		ULONG *
	)

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().

ScCountNotifications()

SCODE WINAPI ScCountNotifications	(	int	,
		LPNOTIFICATION	,
		ULONG *
	)

ScCountProps()

SCODE WINAPI ScCountProps	(	int	,
		LPSPropValue	,
		ULONG *
	)

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;
}

ScInitMapiUtil()

SCODE WINAPI ScInitMapiUtil

(

ULONG

ulReserved

)

Definition at line 67 of file util.c.

{
    if (mapiFunctions.ScInitMapiUtil)
        return mapiFunctions.ScInitMapiUtil(ulReserved);
 
    FIXME("(0x%08x)stub!\n", ulReserved);
    if (ulReserved)
        return MAPI_E_INVALID_PARAMETER;
    return S_OK;
}

SCODE()

typedef SCODE

(

WINAPI

CREATECONVERSATIONINDEX

)

ScRelocNotifications()

SCODE WINAPI ScRelocNotifications	(	int	,
		LPNOTIFICATION	,
		LPVOID	,
		LPVOID	,
		ULONG *
	)

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;
}

SzFindCh()

LPSTR WINAPI SzFindCh	(	LPCSTR	,
		USHORT
	)

SzFindLastCh()

LPSTR WINAPI SzFindLastCh	(	LPCSTR	,
		USHORT
	)

SzFindSz()

LPSTR WINAPI SzFindSz	(	LPCSTR	,
		LPCSTR
	)

UFromSz()

UINT WINAPI UFromSz

(

LPCSTR

lpszStr

)

Definition at line 677 of file util.c.

{
    ULONG ulRet = 0;
 
    TRACE("(%s)\n", debugstr_a(lpszStr));
 
    if (lpszStr)
    {
        while (*lpszStr >= '0' && *lpszStr <= '9')
        {
            ulRet = ulRet * 10 + (*lpszStr - '0');
            lpszStr++;
        }
    }
    return ulRet;
}

UlAddRef()

ULONG WINAPI UlAddRef

(

void *

lpUnk

)

Definition at line 627 of file util.c.

{
    TRACE("(%p)\n", lpUnk);
 
    if (!lpUnk)
        return 0UL;
    return IUnknown_AddRef((LPUNKNOWN)lpUnk);
}

UlFromSzHex()

ULONG WINAPI UlFromSzHex

(

LPCSTR

)

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().

UlRelease()

ULONG WINAPI UlRelease

(

void *

lpUnk

)

Definition at line 652 of file util.c.

{
    TRACE("(%p)\n", lpUnk);
 
    if (!lpUnk)
        return 0UL;
    return IUnknown_Release((LPUNKNOWN)lpUnk);
}

void()

typedef void

(

WINAPI

CALLERRELEASE

)

Variable Documentation

LPBYTE

typedef LPBYTE

Definition at line 112 of file mapiutil.h.

LPMAPITABLE

typedef LPMAPITABLE

Definition at line 117 of file mapiutil.h.