ReactOS 0.4.15-dev-6052-g2626c72
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(WINAPILPOPENSTREAMONFILE) (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.

2310{
2311 IPropDataImpl *lpPropData;
2312 SCODE scode;
2313
2314 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_guid(iid), lpAlloc, lpMore, lpFree,
2315 lpReserved, lppPropData);
2316
2317 if (lppPropData)
2318 *lppPropData = NULL;
2319
2320 if (iid && !IsEqualGUID(iid, &IID_IMAPIPropData))
2322
2323 if (!lpAlloc || !lpMore || !lpFree || lpReserved || !lppPropData)
2325
2326 scode = lpAlloc(sizeof(IPropDataImpl), (LPVOID*)&lpPropData);
2327
2328 if (SUCCEEDED(scode))
2329 {
2330 lpPropData->IPropData_iface.lpVtbl = &IPropDataImpl_vtbl;
2331 lpPropData->lRef = 1;
2332 lpPropData->lpAlloc = lpAlloc;
2333 lpPropData->lpMore = lpMore;
2334 lpPropData->lpFree = lpFree;
2335 lpPropData->ulObjAccess = IPROP_READWRITE;
2336 lpPropData->ulNumValues = 0;
2337 list_init(&lpPropData->values);
2338 InitializeCriticalSection(&lpPropData->cs);
2339 lpPropData->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IPropDataImpl.cs");
2340 *lppPropData = &lpPropData->IPropData_iface;
2341 }
2342 return scode;
2343}
static void list_init(struct list_entry *head)
Definition: list.h:51
#define NULL
Definition: types.h:112
LONG SCODE
Definition: compat.h:2252
static const IPropDataVtbl IPropDataImpl_vtbl
Definition: prop.c:2267
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define debugstr_guid
Definition: kernel32.h:35
#define MAPI_E_INVALID_PARAMETER
Definition: mapicode.h:62
#define MAPI_E_INTERFACE_NOT_SUPPORTED
Definition: mapicode.h:57
#define IPROP_READWRITE
Definition: mapiutil.h:52
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define TRACE(s)
Definition: solgame.cpp:4
FREEBUFFER * lpFree
Definition: prop.c:1415
ALLOCATEBUFFER * lpAlloc
Definition: prop.c:1413
ULONG ulNumValues
Definition: prop.c:1417
ALLOCATEMORE * lpMore
Definition: prop.c:1414
CRITICAL_SECTION cs
Definition: prop.c:1419
struct list values
Definition: prop.c:1418
LONG lRef
Definition: prop.c:1412
IPropData IPropData_iface
Definition: prop.c:1411
ULONG ulObjAccess
Definition: prop.c:1416
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76

◆ 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.

221{
222 /*** IUnknown methods ***/
226 /*** IMAPIProp methods ***/
227 STDMETHOD(GetLastError)(THIS_ HRESULT hRes, ULONG ulFlags, LPMAPIERROR *lppErr) PURE;
228 STDMETHOD(SaveChanges)(THIS_ ULONG ulFlags) PURE;
229 STDMETHOD(GetProps)(THIS_ LPSPropTagArray lpPropTags, ULONG ulFlags, ULONG *lpValues, LPSPropValue *lppProps) PURE;
230 STDMETHOD(GetPropList)(THIS_ ULONG ulFlags, LPSPropTagArray *lppPropTagArray) PURE;
231 STDMETHOD(OpenProperty)(THIS_ ULONG ulPropTag, LPCIID lpIid, ULONG ulOpts, ULONG ulFlags, LPUNKNOWN *lppUnk) PURE;
232 STDMETHOD(SetProps)(THIS_ ULONG cValues, LPSPropValue lpProps, LPSPropProblemArray *lppProbs) PURE;
233 STDMETHOD(DeleteProps)(THIS_ LPSPropTagArray lpPropTags, LPSPropProblemArray *lppProbs) PURE;
234 STDMETHOD(CopyTo)(THIS_ ULONG ciidExclude, LPCIID lpIid, LPSPropTagArray lpProps, ULONG ulParam,
235 LPMAPIPROGRESS lpProgress, LPCIID lpIface,LPVOID lpDest, ULONG ulFlags,
236 LPSPropProblemArray *lppProbs) PURE;
237 STDMETHOD(CopyProps)(THIS_ LPSPropTagArray lpIncludeProps, ULONG ulParam, LPMAPIPROGRESS lpProgress,
238 LPCIID lpIid, LPVOID lpDestObj, ULONG ulFlags, LPSPropProblemArray *lppProblems) PURE;
239 STDMETHOD(GetNamesFromIDs)(THIS_ LPSPropTagArray *lppPropTags, LPGUID lpIid, ULONG ulFlags, ULONG *lpCount,
240 LPMAPINAMEID **lpppNames) PURE;
241 STDMETHOD(GetIDsFromNames)(THIS_ ULONG cPropNames, LPMAPINAMEID *lppNames, ULONG ulFlags, LPSPropTagArray *lppPropTags) PURE;
242 /*** IPropData methods ***/
243 STDMETHOD(HrSetObjAccess)(THIS_ ULONG ulAccess) PURE;
244 STDMETHOD(HrSetPropAccess)(THIS_ LPSPropTagArray lpPropTags, ULONG *lpAccess) PURE;
245 STDMETHOD(HrGetPropAccess)(THIS_ LPSPropTagArray *lppPropTags, ULONG **lppAccess) PURE;
246 STDMETHOD(HrAddObjProps)(THIS_ LPSPropTagArray lppPropTags, LPSPropProblemArray *lppProbs) PURE;
247};
#define THIS_
Definition: basetyps.h:65
#define THIS
Definition: basetyps.h:66
#define PURE
Definition: basetyps.h:64
#define STDMETHOD_(t, m)
Definition: basetyps.h:63
#define STDMETHOD(m)
Definition: basetyps.h:62
_In_ BOOLEAN Release
Definition: cdrom.h:920
REFIID riid
Definition: atlbase.h:39
IMAPIProgress * LPMAPIPROGRESS
Definition: mapidefs.h:96
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
static LPUNKNOWN
Definition: ndr_ole.c:49
#define REFIID
Definition: guiddef.h:118
uint32_t ULONG
Definition: typedefs.h:59
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082

◆ DECLARE_INTERFACE_() [2/2]

DECLARE_INTERFACE_ ( ITableData  ,
IUnknown   
)

Definition at line 125 of file mapiutil.h.

126{
127 /*** IUnknown methods ***/
131 /*** ITableData methods ***/
132 STDMETHOD(HrGetView)(THIS_ LPSSortOrderSet lpSort, CALLERRELEASE *lpRel,
133 ULONG ulData, LPMAPITABLE *lppTable) PURE;
134 STDMETHOD(HrModifyRow)(THIS_ LPSRow lpRow) PURE;
135 STDMETHOD(HrDeleteRow)(THIS_ LPSPropValue lpKey) PURE;
136 STDMETHOD(HrQueryRow)(THIS_ LPSPropValue lpKey, LPSRow *lppRow, ULONG *lpRowNum) PURE;
137 STDMETHOD(HrEnumRow)(THIS_ ULONG ulRowNum, LPSRow *lppRow) PURE;
138 STDMETHOD(HrNotify)(THIS_ ULONG ulFlags, ULONG cValues, LPSPropValue lpValues) PURE;
139 STDMETHOD(HrInsertRow)(THIS_ ULONG ulRow, LPSRow lpRow) PURE;
140 STDMETHOD(HrModifyRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows) PURE;
141 STDMETHOD(HrDeleteRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows, ULONG *lpCount) PURE;
142};
static LPCTSTR lpKey
Definition: virtmem.c:102
IMAPITable * LPMAPITABLE
Definition: mapidefs.h:840

◆ DeinitMapiUtil()

void WINAPI DeinitMapiUtil ( void  )

Definition at line 93 of file util.c.

94{
95 if (mapiFunctions.DeinitMapiUtil)
96 mapiFunctions.DeinitMapiUtil();
97 else
98 FIXME("()stub!\n");
99}
#define FIXME(fmt,...)
Definition: debug.h:111
MAPI_FUNCTIONS mapiFunctions
Definition: util.c:49

◆ FBinFromHex()

BOOL WINAPI FBinFromHex ( LPSTR  ,
LPBYTE   
)

◆ FEqualNames()

BOOL WINAPI FEqualNames ( LPMAPINAMEID  lpName1,
LPMAPINAMEID  lpName2 
)

Definition at line 486 of file util.c.

487{
488 TRACE("(%p,%p)\n", lpName1, lpName2);
489
490 if (!lpName1 || !lpName2 ||
491 !IsEqualGUID(lpName1->lpguid, lpName2->lpguid) ||
492 lpName1->ulKind != lpName2->ulKind)
493 return FALSE;
494
495 if (lpName1->ulKind == MNID_STRING)
496 return !lstrcmpW(lpName1->Kind.lpwstrName, lpName2->Kind.lpwstrName);
497
498 return lpName1->Kind.lID == lpName2->Kind.lID;
499}
#define FALSE
Definition: types.h:117
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define MNID_STRING
Definition: mapidefs.h:638
ULONG ulKind
Definition: mapidefs.h:643
LPWSTR lpwstrName
Definition: mapidefs.h:647
LPGUID lpguid
Definition: mapidefs.h:642
LONG lID
Definition: mapidefs.h:646
union _MAPINAMEID::@3015 Kind

◆ FPropCompareProp()

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

Definition at line 399 of file prop.c.

400{
401 LONG iCmp;
402
403 TRACE("(%p,%d,%p)\n", lpPropLeft, ulOp, lpPropRight);
404
405 if (ulOp > RELOP_RE || FBadProp(lpPropLeft) || FBadProp(lpPropRight))
406 return FALSE;
407
408 if (ulOp == RELOP_RE)
409 {
410 FIXME("Comparison operator RELOP_RE not yet implemented!\n");
411 return FALSE;
412 }
413
414 iCmp = LPropCompareProp(lpPropLeft, lpPropRight);
415
416 switch (ulOp)
417 {
418 case RELOP_LT: return iCmp < 0;
419 case RELOP_LE: return iCmp <= 0;
420 case RELOP_GT: return iCmp > 0;
421 case RELOP_GE: return iCmp >= 0;
422 case RELOP_EQ: return iCmp == 0;
423 case RELOP_NE: return iCmp != 0;
424 }
425 return FALSE;
426}
ULONG WINAPI FBadProp(LPSPropValue lpProp)
Definition: prop.c:1288
LONG WINAPI LPropCompareProp(LPSPropValue lpPropLeft, LPSPropValue lpPropRight)
Definition: prop.c:441
#define RELOP_LT
Definition: mapidefs.h:510
#define RELOP_EQ
Definition: mapidefs.h:514
#define RELOP_GT
Definition: mapidefs.h:512
#define RELOP_NE
Definition: mapidefs.h:515
#define RELOP_LE
Definition: mapidefs.h:511
#define RELOP_GE
Definition: mapidefs.h:513
#define RELOP_RE
Definition: mapidefs.h:516
long LONG
Definition: pedump.c:60

◆ FPropContainsProp()

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

Definition at line 300 of file prop.c.

301{
302 TRACE("(%p,%p,0x%08x)\n", lpHaystack, lpNeedle, ulFuzzy);
303
304 if (FBadProp(lpHaystack) || FBadProp(lpNeedle) ||
305 PROP_TYPE(lpHaystack->ulPropTag) != PROP_TYPE(lpNeedle->ulPropTag))
306 return FALSE;
307
308 /* FIXME: Do later versions support Unicode as well? */
309
310 if (PROP_TYPE(lpHaystack->ulPropTag) == PT_STRING8)
311 {
312 DWORD dwFlags = 0, dwNeedleLen, dwHaystackLen;
313
314 if (ulFuzzy & FL_IGNORECASE)
316 if (ulFuzzy & FL_IGNORENONSPACE)
318 if (ulFuzzy & FL_LOOSE)
320
321 dwNeedleLen = lstrlenA(lpNeedle->Value.lpszA);
322 dwHaystackLen = lstrlenA(lpHaystack->Value.lpszA);
323
324 if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
325 {
326 if (dwNeedleLen <= dwHaystackLen &&
328 lpHaystack->Value.lpszA, dwNeedleLen,
329 lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
330 return TRUE; /* needle is a prefix of haystack */
331 }
332 else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
333 {
334 LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD) = StrChrA;
335 LPSTR lpStr = lpHaystack->Value.lpszA;
336
338 pStrChrFn = StrChrIA;
339
340 while ((lpStr = pStrChrFn(lpStr, *lpNeedle->Value.lpszA)) != NULL)
341 {
342 dwHaystackLen -= (lpStr - lpHaystack->Value.lpszA);
343 if (dwNeedleLen <= dwHaystackLen &&
345 lpStr, dwNeedleLen,
346 lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
347 return TRUE; /* needle is a substring of haystack */
348 lpStr++;
349 }
350 }
352 lpHaystack->Value.lpszA, dwHaystackLen,
353 lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
354 return TRUE; /* full string match */
355 }
356 else if (PROP_TYPE(lpHaystack->ulPropTag) == PT_BINARY)
357 {
358 if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
359 {
360 if (lpNeedle->Value.bin.cb <= lpHaystack->Value.bin.cb &&
361 !memcmp(lpNeedle->Value.bin.lpb, lpHaystack->Value.bin.lpb,
362 lpNeedle->Value.bin.cb))
363 return TRUE; /* needle is a prefix of haystack */
364 }
365 else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
366 {
367 ULONG ulLen = lpHaystack->Value.bin.cb;
368 LPBYTE lpb = lpHaystack->Value.bin.lpb;
369
370 while ((lpb = memchr(lpb, *lpNeedle->Value.bin.lpb, ulLen)) != NULL)
371 {
372 ulLen = lpHaystack->Value.bin.cb - (lpb - lpHaystack->Value.bin.lpb);
373 if (lpNeedle->Value.bin.cb <= ulLen &&
374 !memcmp(lpNeedle->Value.bin.lpb, lpb, lpNeedle->Value.bin.cb))
375 return TRUE; /* needle is a substring of haystack */
376 lpb++;
377 }
378 }
379 else if (!LPropCompareProp(lpHaystack, lpNeedle))
380 return TRUE; /* needle is an exact match with haystack */
381
382 }
383 return FALSE;
384}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define TRUE
Definition: types.h:120
LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
Definition: string.c:614
LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
Definition: string.c:270
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: lang.c:2622
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define FL_IGNORENONSPACE
Definition: mapidefs.h:453
#define PT_STRING8
Definition: mapidefs.h:210
#define FL_LOOSE
Definition: mapidefs.h:454
#define FL_IGNORECASE
Definition: mapidefs.h:452
#define FL_SUBSTRING
Definition: mapidefs.h:450
#define FL_PREFIX
Definition: mapidefs.h:451
#define PROP_TYPE(t)
Definition: mapidefs.h:238
#define PT_BINARY
Definition: mapidefs.h:214
#define memchr(s, c, n)
Definition: mkisofs.h:875
#define LOCALE_USER_DEFAULT
LPBYTE lpb
Definition: mapidefs.h:290
ULONG cb
Definition: mapidefs.h:289
ULONG ulPropTag
Definition: mapidefs.h:408
union _PV Value
Definition: mapidefs.h:410
unsigned char * LPBYTE
Definition: typedefs.h:53
SBinary bin
Definition: mapidefs.h:385
LPSTR lpszA
Definition: mapidefs.h:384
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define WINAPI
Definition: msvc.h:6
#define NORM_IGNORECASE
Definition: winnls.h:176
#define CSTR_EQUAL
Definition: winnls.h:456
#define NORM_IGNORENONSPACE
Definition: winnls.h:178
#define NORM_IGNORESYMBOLS
Definition: winnls.h:179
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182

◆ FPropExists()

BOOL WINAPI FPropExists ( LPMAPIPROP  lpIProp,
ULONG  ulPropTag 
)

Definition at line 592 of file prop.c.

593 {
594 BOOL bRet = FALSE;
595
596 TRACE("(%p,%d)\n", lpIProp, ulPropTag);
597
598 if (lpIProp)
599 {
600 LPSPropTagArray lpTags;
601 ULONG i;
602
603 if (FAILED(IMAPIProp_GetPropList(lpIProp, 0u, &lpTags)))
604 return FALSE;
605
606 for (i = 0; i < lpTags->cValues; i++)
607 {
608 if (!FBadPropTag(lpTags->aulPropTag[i]) &&
609 (lpTags->aulPropTag[i] == ulPropTag ||
610 (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
611 PROP_ID(lpTags->aulPropTag[i]) == lpTags->aulPropTag[i])))
612 {
613 bRet = TRUE;
614 break;
615 }
616 }
617 MAPIFreeBuffer(lpTags);
618 }
619 return bRet;
620}
ULONG WINAPI FBadPropTag(ULONG ulPropTag)
Definition: prop.c:1221
unsigned int BOOL
Definition: ntddk_ex.h:94
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define FAILED(hr)
Definition: intsafe.h:51
MAPIFREEBUFFER MAPIFreeBuffer
Definition: mapi.h:206
#define PT_UNSPECIFIED
Definition: mapidefs.h:193
#define IMAPIProp_GetPropList(p, a, b)
Definition: mapidefs.h:904
#define PROP_ID(t)
Definition: mapidefs.h:239
ULONG aulPropTag[MAPI_DIM]
Definition: mapidefs.h:271
ULONG cValues
Definition: mapidefs.h:270

◆ FreePadrlist()

void WINAPI FreePadrlist ( LPADRLIST  lpAddrs)

Definition at line 669 of file prop.c.

670{
671 TRACE("(%p)\n", lpAddrs);
672
673 /* Structures are binary compatible; use the same implementation */
674 FreeProws((LPSRowSet)lpAddrs);
675}
VOID WINAPI FreeProws(LPSRowSet lpRowSet)
Definition: prop.c:688

◆ FreeProws()

void WINAPI FreeProws ( LPSRowSet  lpRowSet)

Definition at line 688 of file prop.c.

689{
690 TRACE("(%p)\n", lpRowSet);
691
692 if (lpRowSet)
693 {
694 ULONG i;
695
696 for (i = 0; i < lpRowSet->cRows; i++)
697 MAPIFreeBuffer(lpRowSet->aRow[i].lpProps);
698
699 MAPIFreeBuffer(lpRowSet);
700 }
701}
ULONG cRows
Definition: mapidefs.h:424
SRow aRow[MAPI_DIM]
Definition: mapidefs.h:425
LPSPropValue lpProps
Definition: mapidefs.h:418

Referenced by FreePadrlist(), and sendmail_extended_mapi().

◆ FtAddFt()

static FILETIME FtAddFt ( FILETIME  ftLeft,
FILETIME  ftRight 
)
inlinestatic

Definition at line 175 of file mapiutil.h.

176{
177 LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight;
178 union { FILETIME ft; LONG64 ll; } ftmap;
179 ftmap.ll = *pl + *pr;
180 return ftmap.ft;
181}
w ll
Definition: byte_order.h:167
int64_t LONG64
Definition: typedefs.h:68

◆ FtMulDw()

static FILETIME FtMulDw ( DWORD  dwLeft,
FILETIME  ftRight 
)
inlinestatic

Definition at line 199 of file mapiutil.h.

200{
201 LONG64 l = (LONG64)dwLeft, *pr = (LONG64*)&ftRight;
202 union { FILETIME ft; LONG64 ll; } ftmap;
203 ftmap.ll = l * (*pr);
204 return ftmap.ft;
205}
r l[0]
Definition: byte_order.h:168

◆ FtMulDwDw()

static FILETIME FtMulDwDw ( DWORD  dwLeft,
DWORD  dwRight 
)
inlinestatic

Definition at line 207 of file mapiutil.h.

208{
209 LONG64 l = (LONG64)dwLeft, r = (LONG64)dwRight;
210 union { FILETIME ft; LONG64 ll; } ftmap;
211 ftmap.ll = l * r;
212 return ftmap.ft;
213}
GLdouble GLdouble GLdouble r
Definition: gl.h:2055

◆ FtNegFt()

static FILETIME FtNegFt ( FILETIME  ftLeft)
inlinestatic

Definition at line 191 of file mapiutil.h.

192{
193 LONG64 *p = (LONG64*)&ftLeft;
194 union { FILETIME ft; LONG64 ll; } ftmap;
195 ftmap.ll = -*p;
196 return ftmap.ft;
197}
GLfloat GLfloat p
Definition: glext.h:8902

◆ FtSubFt()

static FILETIME FtSubFt ( FILETIME  ftLeft,
FILETIME  ftRight 
)
inlinestatic

Definition at line 183 of file mapiutil.h.

184{
185 LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight;
186 union { FILETIME ft; LONG64 ll; } ftmap;
187 ftmap.ll = *pl - *pr;
188 return ftmap.ft;
189}

◆ GetInstance()

VOID WINAPI GetInstance ( LPSPropValue  ,
LPSPropValue  ,
ULONG   
)

◆ HexFromBin()

void WINAPI HexFromBin ( LPBYTE  ,
int  ,
LPSTR   
)

◆ HrAddColumns()

◆ HrAddColumnsEx()

◆ HrAllocAdviseSink()

HRESULT WINAPI HrAllocAdviseSink ( LPNOTIFCALLBACK  ,
LPVOID  ,
LPMAPIADVISESINK  
)

◆ HrDispatchNotifications()

HRESULT WINAPI HrDispatchNotifications ( ULONG  flags)

Definition at line 243 of file util.c.

244{
245 FIXME("(%08x)\n", flags);
246 return S_OK;
247}
GLbitfield flags
Definition: glext.h:7161
#define S_OK
Definition: intsafe.h:52

◆ HRESULT()

typedef HRESULT ( WINAPI  DISPATCHNOTIFICATIONS)

◆ HrGetOneProp()

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

Definition at line 535 of file prop.c.

536{
537 SPropTagArray pta;
538 ULONG ulCount;
539 HRESULT hRet;
540
541 TRACE("(%p,%d,%p)\n", lpIProp, ulPropTag, lppProp);
542
543 pta.cValues = 1u;
544 pta.aulPropTag[0] = ulPropTag;
545 hRet = IMAPIProp_GetProps(lpIProp, &pta, 0u, &ulCount, lppProp);
546 if (hRet == MAPI_W_ERRORS_RETURNED)
547 {
548 MAPIFreeBuffer(*lppProp);
549 *lppProp = NULL;
550 hRet = MAPI_E_NOT_FOUND;
551 }
552 return hRet;
553}
#define MAPI_E_NOT_FOUND
Definition: mapicode.h:76
#define MAPI_W_ERRORS_RETURNED
Definition: mapicode.h:109
#define IMAPIProp_GetProps(p, a, b, c, d)
Definition: mapidefs.h:903

◆ HrQueryAllRows()

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

Definition at line 933 of file util.c.

936{
937 if (mapiFunctions.HrQueryAllRows)
938 return mapiFunctions.HrQueryAllRows(lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
939
940 FIXME("(%p, %p, %p, %p, %d, %p): stub\n", lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
941 *lppRows = NULL;
942 return MAPI_E_CALL_FAILED;
943}
#define MAPI_E_CALL_FAILED
Definition: mapicode.h:43

◆ HrSetOneProp()

HRESULT WINAPI HrSetOneProp ( LPMAPIPROP  lpIProp,
LPSPropValue  lpProp 
)

Definition at line 568 of file prop.c.

569{
570 TRACE("(%p,%p)\n", lpIProp, lpProp);
571
572 return IMAPIProp_SetProps(lpIProp, 1u, lpProp, NULL);
573}
#define IMAPIProp_SetProps(p, a, b, c)
Definition: mapidefs.h:906

◆ HrThisThreadAdviseSink()

HRESULT WINAPI HrThisThreadAdviseSink ( LPMAPIADVISESINK  lpSink,
LPMAPIADVISESINK lppNewSink 
)

Definition at line 262 of file util.c.

263{
264 if (mapiFunctions.HrThisThreadAdviseSink)
265 return mapiFunctions.HrThisThreadAdviseSink(lpSink, lppNewSink);
266
267 FIXME("(%p,%p)semi-stub\n", lpSink, lppNewSink);
268
269 if (!lpSink || !lppNewSink)
270 return E_INVALIDARG;
271
272 /* Don't wrap the sink for now, just copy it */
273 *lppNewSink = lpSink;
275 return S_OK;
276}
#define E_INVALIDARG
Definition: ddrawi.h:101
#define IMAPIAdviseSink_AddRef(p)
Definition: mapidefs.h:860

◆ LPropCompareProp()

LONG WINAPI LPropCompareProp ( LPSPropValue  lpPropLeft,
LPSPropValue  lpPropRight 
)

Definition at line 441 of file prop.c.

442{
443 LONG iRet;
444
445 TRACE("(%p->0x%08x,%p->0x%08x)\n", lpPropLeft, lpPropLeft->ulPropTag,
446 lpPropRight, lpPropRight->ulPropTag);
447
448 /* If the properties are not the same, sort by property type */
449 if (PROP_TYPE(lpPropLeft->ulPropTag) != PROP_TYPE(lpPropRight->ulPropTag))
450 return (LONG)PROP_TYPE(lpPropLeft->ulPropTag) - (LONG)PROP_TYPE(lpPropRight->ulPropTag);
451
452 switch (PROP_TYPE(lpPropLeft->ulPropTag))
453 {
454 case PT_UNSPECIFIED:
455 case PT_NULL:
456 return 0; /* NULLs are equal */
457 case PT_I2:
458 return lpPropLeft->Value.i - lpPropRight->Value.i;
459 case PT_I4:
460 return lpPropLeft->Value.l - lpPropRight->Value.l;
461 case PT_I8:
462 if (lpPropLeft->Value.li.QuadPart > lpPropRight->Value.li.QuadPart)
463 return 1;
464 if (lpPropLeft->Value.li.QuadPart == lpPropRight->Value.li.QuadPart)
465 return 0;
466 return -1;
467 case PT_R4:
468 if (lpPropLeft->Value.flt > lpPropRight->Value.flt)
469 return 1;
470 if (lpPropLeft->Value.flt == lpPropRight->Value.flt)
471 return 0;
472 return -1;
473 case PT_APPTIME:
474 case PT_R8:
475 if (lpPropLeft->Value.dbl > lpPropRight->Value.dbl)
476 return 1;
477 if (lpPropLeft->Value.dbl == lpPropRight->Value.dbl)
478 return 0;
479 return -1;
480 case PT_CURRENCY:
481 if (lpPropLeft->Value.cur.int64 > lpPropRight->Value.cur.int64)
482 return 1;
483 if (lpPropLeft->Value.cur.int64 == lpPropRight->Value.cur.int64)
484 return 0;
485 return -1;
486 case PT_SYSTIME:
487 return CompareFileTime(&lpPropLeft->Value.ft, &lpPropRight->Value.ft);
488 case PT_BOOLEAN:
489 return (lpPropLeft->Value.b ? 1 : 0) - (lpPropRight->Value.b ? 1 : 0);
490 case PT_BINARY:
491 if (lpPropLeft->Value.bin.cb == lpPropRight->Value.bin.cb)
492 iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
493 lpPropLeft->Value.bin.cb);
494 else
495 {
496 iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
497 min(lpPropLeft->Value.bin.cb, lpPropRight->Value.bin.cb));
498
499 if (!iRet)
500 iRet = lpPropLeft->Value.bin.cb - lpPropRight->Value.bin.cb;
501 }
502 return iRet;
503 case PT_STRING8:
504 return lstrcmpA(lpPropLeft->Value.lpszA, lpPropRight->Value.lpszA);
505 case PT_UNICODE:
506 return lstrcmpW(lpPropLeft->Value.lpszW, lpPropRight->Value.lpszW);
507 case PT_ERROR:
508 if (lpPropLeft->Value.err > lpPropRight->Value.err)
509 return 1;
510 if (lpPropLeft->Value.err == lpPropRight->Value.err)
511 return 0;
512 return -1;
513 case PT_CLSID:
514 return memcmp(lpPropLeft->Value.lpguid, lpPropRight->Value.lpguid,
515 sizeof(GUID));
516 }
517 FIXME("Unhandled property type %d\n", PROP_TYPE(lpPropLeft->ulPropTag));
518 return 0;
519}
LONG WINAPI CompareFileTime(IN CONST FILETIME *lpFileTime1, IN CONST FILETIME *lpFileTime2)
Definition: time.c:106
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
#define PT_CURRENCY
Definition: mapidefs.h:203
#define PT_UNICODE
Definition: mapidefs.h:211
#define PT_R8
Definition: mapidefs.h:202
#define PT_R4
Definition: mapidefs.h:199
#define PT_ERROR
Definition: mapidefs.h:205
#define PT_NULL
Definition: mapidefs.h:194
#define PT_I8
Definition: mapidefs.h:208
#define PT_CLSID
Definition: mapidefs.h:213
#define PT_I2
Definition: mapidefs.h:195
#define PT_SYSTIME
Definition: mapidefs.h:212
#define PT_APPTIME
Definition: mapidefs.h:204
#define PT_BOOLEAN
Definition: mapidefs.h:206
#define PT_I4
Definition: mapidefs.h:198
#define min(a, b)
Definition: monoChain.cc:55
LONGLONG QuadPart
Definition: typedefs.h:114
LARGE_INTEGER li
Definition: mapidefs.h:388
LONG l
Definition: mapidefs.h:376
unsigned short b
Definition: mapidefs.h:380
LPWSTR lpszW
Definition: mapidefs.h:386
short int i
Definition: mapidefs.h:375
CY cur
Definition: mapidefs.h:381
SCODE err
Definition: mapidefs.h:401
float flt
Definition: mapidefs.h:378
FILETIME ft
Definition: mapidefs.h:383
LPGUID lpguid
Definition: mapidefs.h:387
double dbl
Definition: mapidefs.h:379
LONGLONG int64
Definition: compat.h:2265

Referenced by FPropCompareProp(), and FPropContainsProp().

◆ LpValFindProp()

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

Definition at line 1076 of file prop.c.

1077{
1078 TRACE("(%d,%d,%p)\n", ulPropTag, cValues, lpProps);
1079
1080 if (lpProps && cValues)
1081 {
1082 ULONG i;
1083 for (i = 0; i < cValues; i++)
1084 {
1085 if (PROP_ID(ulPropTag) == PROP_ID(lpProps[i].ulPropTag))
1086 return &lpProps[i];
1087 }
1088 }
1089 return NULL;
1090}

◆ MAPIGetDefaultMalloc()

LPMALLOC WINAPI MAPIGetDefaultMalloc ( void  )

Definition at line 62 of file imalloc.c.

63{
64 TRACE("()\n");
65
66 if (mapiFunctions.MAPIGetDefaultMalloc)
67 return mapiFunctions.MAPIGetDefaultMalloc();
68
69 IMalloc_AddRef(&MAPI_IMalloc.IMalloc_iface);
71}
static MAPI_IMALLOC MAPI_IMalloc
Definition: imalloc.c:47
IMalloc IMalloc_iface
Definition: imalloc.c:43

◆ 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.

640{
641 TRACE("(%p,%d,%d)\n", lpProps, cValues, ulPropTag);
642
643 if (lpProps && cValues)
644 {
645 ULONG i;
646 for (i = 0; i < cValues; i++)
647 {
648 if (!FBadPropTag(lpProps[i].ulPropTag) &&
649 (lpProps[i].ulPropTag == ulPropTag ||
650 (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
651 PROP_ID(lpProps[i].ulPropTag) == PROP_ID(ulPropTag))))
652 return &lpProps[i];
653 }
654 }
655 return NULL;
656}

◆ PropCopyMore()

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

Definition at line 64 of file prop.c.

66{
67 ULONG ulLen, i;
68 SCODE scode = S_OK;
69
70 TRACE("(%p,%p,%p,%p)\n", lpDest, lpSrc, lpMore, lpOrig);
71
72 if (!lpDest || IsBadWritePtr(lpDest, sizeof(SPropValue)) ||
73 FBadProp(lpSrc) || !lpMore)
75
76 /* Shallow copy first, this is sufficient for properties without pointers */
77 *lpDest = *lpSrc;
78
79 switch (PROP_TYPE(lpSrc->ulPropTag))
80 {
81 case PT_CLSID:
82 scode = lpMore(sizeof(GUID), lpOrig, (LPVOID*)&lpDest->Value.lpguid);
83 if (SUCCEEDED(scode))
84 *lpDest->Value.lpguid = *lpSrc->Value.lpguid;
85 break;
86 case PT_STRING8:
87 ulLen = lstrlenA(lpSrc->Value.lpszA) + 1u;
88 scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszA);
89 if (SUCCEEDED(scode))
90 memcpy(lpDest->Value.lpszA, lpSrc->Value.lpszA, ulLen);
91 break;
92 case PT_UNICODE:
93 ulLen = (lstrlenW(lpSrc->Value.lpszW) + 1u) * sizeof(WCHAR);
94 scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszW);
95 if (SUCCEEDED(scode))
96 memcpy(lpDest->Value.lpszW, lpSrc->Value.lpszW, ulLen);
97 break;
98 case PT_BINARY:
99 scode = lpMore(lpSrc->Value.bin.cb, lpOrig, (LPVOID*)&lpDest->Value.bin.lpb);
100 if (SUCCEEDED(scode))
101 memcpy(lpDest->Value.bin.lpb, lpSrc->Value.bin.lpb, lpSrc->Value.bin.cb);
102 break;
103 default:
104 if (lpSrc->ulPropTag & MV_FLAG)
105 {
106 ulLen = UlPropSize(lpSrc);
107
108 if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_STRING8 ||
110 {
111 /* UlPropSize doesn't account for the string pointers */
112 ulLen += lpSrc->Value.MVszA.cValues * sizeof(char*);
113 }
114 else if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_BINARY)
115 {
116 /* UlPropSize doesn't account for the SBinary structs */
117 ulLen += lpSrc->Value.MVbin.cValues * sizeof(SBinary);
118 }
119
120 lpDest->Value.MVi.cValues = lpSrc->Value.MVi.cValues;
121 scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.MVi.lpi);
122 if (FAILED(scode))
123 break;
124
125 /* Note that we could allocate the memory for each value in a
126 * multi-value property separately, however if an allocation failed
127 * we would be left with a bunch of allocated memory, which (while
128 * not really leaked) is unusable until lpOrig is freed. So for
129 * strings and binary arrays we make a single allocation for all
130 * of the data. This is consistent since individual elements can't
131 * be freed anyway.
132 */
133
134 switch (PROP_TYPE(lpSrc->ulPropTag))
135 {
136 case PT_MV_STRING8:
137 {
138 char *lpNextStr = (char*)(lpDest->Value.MVszA.lppszA +
139 lpDest->Value.MVszA.cValues);
140
141 for (i = 0; i < lpSrc->Value.MVszA.cValues; i++)
142 {
143 ULONG ulStrLen = lstrlenA(lpSrc->Value.MVszA.lppszA[i]) + 1u;
144
145 lpDest->Value.MVszA.lppszA[i] = lpNextStr;
146 memcpy(lpNextStr, lpSrc->Value.MVszA.lppszA[i], ulStrLen);
147 lpNextStr += ulStrLen;
148 }
149 break;
150 }
151 case PT_MV_UNICODE:
152 {
153 WCHAR *lpNextStr = (WCHAR*)(lpDest->Value.MVszW.lppszW +
154 lpDest->Value.MVszW.cValues);
155
156 for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
157 {
158 ULONG ulStrLen = lstrlenW(lpSrc->Value.MVszW.lppszW[i]) + 1u;
159
160 lpDest->Value.MVszW.lppszW[i] = lpNextStr;
161 memcpy(lpNextStr, lpSrc->Value.MVszW.lppszW[i], ulStrLen * sizeof(WCHAR));
162 lpNextStr += ulStrLen;
163 }
164 break;
165 }
166 case PT_MV_BINARY:
167 {
168 LPBYTE lpNext = (LPBYTE)(lpDest->Value.MVbin.lpbin +
169 lpDest->Value.MVbin.cValues);
170
171 for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
172 {
173 lpDest->Value.MVbin.lpbin[i].cb = lpSrc->Value.MVbin.lpbin[i].cb;
174 lpDest->Value.MVbin.lpbin[i].lpb = lpNext;
175 memcpy(lpNext, lpSrc->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
176 lpNext += lpDest->Value.MVbin.lpbin[i].cb;
177 }
178 break;
179 }
180 default:
181 /* No embedded pointers, just copy the data over */
182 memcpy(lpDest->Value.MVi.lpi, lpSrc->Value.MVi.lpi, ulLen);
183 break;
184 }
185 break;
186 }
187 }
188 return scode;
189}
#define lstrlenW
Definition: compat.h:750
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:881
ULONG WINAPI UlPropSize(LPSPropValue lpProp)
Definition: prop.c:213
#define PT_MV_STRING8
Definition: mapidefs.h:259
#define MV_FLAG
Definition: mapidefs.h:216
#define PT_MV_BINARY
Definition: mapidefs.h:260
struct _SBinary SBinary
#define PT_MV_UNICODE
Definition: mapidefs.h:261
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ULONG cValues
Definition: mapidefs.h:296
SBinary * lpbin
Definition: mapidefs.h:297
LPSTR * lppszA
Definition: mapidefs.h:348
ULONG cValues
Definition: mapidefs.h:347
ULONG cValues
Definition: mapidefs.h:361
short int * lpi
Definition: mapidefs.h:362
LPWSTR * lppszW
Definition: mapidefs.h:369
ULONG cValues
Definition: mapidefs.h:368
SShortArray MVi
Definition: mapidefs.h:389
SLPSTRArray MVszA
Definition: mapidefs.h:397
SWStringArray MVszW
Definition: mapidefs.h:398
SBinaryArray MVbin
Definition: mapidefs.h:396
__wchar_t WCHAR
Definition: xmlstorage.h:180

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.

801{
802 LPSPropValue lpDest = (LPSPropValue)lpDst;
803 char *lpDataDest = (char *)(lpDest + cValues);
804 ULONG ulLen, i;
805 int iter;
806
807 TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpDst, lpCount);
808
809 if (!lpProps || cValues < 0 || !lpDest)
811
812 memcpy(lpDst, lpProps, cValues * sizeof(SPropValue));
813
814 for (iter = 0; iter < cValues; iter++)
815 {
816 switch (PROP_TYPE(lpProps->ulPropTag))
817 {
818 case PT_CLSID:
819 lpDest->Value.lpguid = (LPGUID)lpDataDest;
820 *lpDest->Value.lpguid = *lpProps->Value.lpguid;
821 lpDataDest += sizeof(GUID);
822 break;
823 case PT_STRING8:
824 ulLen = lstrlenA(lpProps->Value.lpszA) + 1u;
825 lpDest->Value.lpszA = lpDataDest;
826 memcpy(lpDest->Value.lpszA, lpProps->Value.lpszA, ulLen);
827 lpDataDest += ulLen;
828 break;
829 case PT_UNICODE:
830 ulLen = (lstrlenW(lpProps->Value.lpszW) + 1u) * sizeof(WCHAR);
831 lpDest->Value.lpszW = (LPWSTR)lpDataDest;
832 memcpy(lpDest->Value.lpszW, lpProps->Value.lpszW, ulLen);
833 lpDataDest += ulLen;
834 break;
835 case PT_BINARY:
836 lpDest->Value.bin.lpb = (LPBYTE)lpDataDest;
837 memcpy(lpDest->Value.bin.lpb, lpProps->Value.bin.lpb, lpProps->Value.bin.cb);
838 lpDataDest += lpProps->Value.bin.cb;
839 break;
840 default:
841 if (lpProps->ulPropTag & MV_FLAG)
842 {
843 lpDest->Value.MVi.cValues = lpProps->Value.MVi.cValues;
844 /* Note: Assignment uses lppszA but covers all cases by union aliasing */
845 lpDest->Value.MVszA.lppszA = (char**)lpDataDest;
846
847 switch (PROP_TYPE(lpProps->ulPropTag))
848 {
849 case PT_MV_STRING8:
850 {
851 lpDataDest += lpProps->Value.MVszA.cValues * sizeof(char *);
852
853 for (i = 0; i < lpProps->Value.MVszA.cValues; i++)
854 {
855 ULONG ulStrLen = lstrlenA(lpProps->Value.MVszA.lppszA[i]) + 1u;
856
857 lpDest->Value.MVszA.lppszA[i] = lpDataDest;
858 memcpy(lpDataDest, lpProps->Value.MVszA.lppszA[i], ulStrLen);
859 lpDataDest += ulStrLen;
860 }
861 break;
862 }
863 case PT_MV_UNICODE:
864 {
865 lpDataDest += lpProps->Value.MVszW.cValues * sizeof(WCHAR *);
866
867 for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
868 {
869 ULONG ulStrLen = (lstrlenW(lpProps->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
870
871 lpDest->Value.MVszW.lppszW[i] = (LPWSTR)lpDataDest;
872 memcpy(lpDataDest, lpProps->Value.MVszW.lppszW[i], ulStrLen);
873 lpDataDest += ulStrLen;
874 }
875 break;
876 }
877 case PT_MV_BINARY:
878 {
879 lpDataDest += lpProps->Value.MVszW.cValues * sizeof(SBinary);
880
881 for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
882 {
883 lpDest->Value.MVbin.lpbin[i].cb = lpProps->Value.MVbin.lpbin[i].cb;
884 lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)lpDataDest;
885 memcpy(lpDataDest, lpProps->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
886 lpDataDest += lpDest->Value.MVbin.lpbin[i].cb;
887 }
888 break;
889 }
890 default:
891 /* No embedded pointers, just copy the data over */
892 ulLen = UlPropSize(lpProps);
893 memcpy(lpDest->Value.MVi.lpi, lpProps->Value.MVi.lpi, ulLen);
894 lpDataDest += ulLen;
895 break;
896 }
897 break;
898 }
899 }
900 lpDest++;
901 lpProps++;
902 }
903 if (lpCount)
904 *lpCount = lpDataDest - (char *)lpDst;
905
906 return S_OK;
907}
struct _SPropValue * LPSPropValue
Definition: prop.c:38
GUID * LPGUID
Definition: guiddef.h:81
WCHAR * LPWSTR
Definition: xmlstorage.h:184

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.

1110{
1111 ULONG ulCount;
1112 SCODE sc;
1113
1114 TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpAlloc, lpNewProp);
1115
1116 sc = ScCountProps(cValues, lpProps, &ulCount);
1117 if (SUCCEEDED(sc))
1118 {
1119 sc = lpAlloc(ulCount, (LPVOID*)lpNewProp);
1120 if (SUCCEEDED(sc))
1121 sc = ScCopyProps(cValues, lpProps, *lpNewProp, &ulCount);
1122 }
1123 return sc;
1124}
SCODE WINAPI ScCopyProps(int cValues, LPSPropValue lpProps, LPVOID lpDst, ULONG *lpCount)
Definition: prop.c:800
SCODE WINAPI ScCountProps(INT iCount, LPSPropValue lpProps, ULONG *pcBytes)
Definition: prop.c:719

◆ ScInitMapiUtil()

SCODE WINAPI ScInitMapiUtil ( ULONG  ulReserved)

Definition at line 67 of file util.c.

68{
69 if (mapiFunctions.ScInitMapiUtil)
70 return mapiFunctions.ScInitMapiUtil(ulReserved);
71
72 FIXME("(0x%08x)stub!\n", ulReserved);
73 if (ulReserved)
75 return S_OK;
76}
_In_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ RECTL _In_ RECTL _In_ ULONG _In_ ULONG ulReserved
Definition: winddi.h:4196

◆ 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.

936{
937 static const BOOL bBadPtr = TRUE; /* Windows bug - Assumes source is bad */
938 LPSPropValue lpDest = lpProps;
939 ULONG ulCount = cValues * sizeof(SPropValue);
940 ULONG ulLen, i;
941 int iter;
942
943 TRACE("(%d,%p,%p,%p,%p)\n", cValues, lpProps, lpOld, lpNew, lpCount);
944
945 if (!lpProps || cValues < 0 || !lpOld || !lpNew)
947
948 /* The reason native doesn't work as MSDN states is that it assumes that
949 * the lpProps pointer contains valid pointers. This is obviously not
950 * true if the array is being read back from serialisation (the pointers
951 * are just offsets). Native can't actually work converting the pointers to
952 * offsets either, because it converts any array pointers to offsets then
953 * _dereferences the offset_ in order to convert the array elements!
954 *
955 * The code below would handle both cases except that the design of this
956 * function makes it impossible to know when the pointers in lpProps are
957 * valid. If both lpOld and lpNew are non-NULL, native reads the pointers
958 * after converting them, so we must do the same. It seems this
959 * functionality was never tested by MS.
960 */
961
962#define RELOC_PTR(p) (((char*)(p)) - (char*)lpOld + (char*)lpNew)
963
964 for (iter = 0; iter < cValues; iter++)
965 {
966 switch (PROP_TYPE(lpDest->ulPropTag))
967 {
968 case PT_CLSID:
969 lpDest->Value.lpguid = (LPGUID)RELOC_PTR(lpDest->Value.lpguid);
970 ulCount += sizeof(GUID);
971 break;
972 case PT_STRING8:
973 ulLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.lpszA) + 1u;
974 lpDest->Value.lpszA = RELOC_PTR(lpDest->Value.lpszA);
975 if (bBadPtr)
976 ulLen = lstrlenA(lpDest->Value.lpszA) + 1u;
977 ulCount += ulLen;
978 break;
979 case PT_UNICODE:
980 ulLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
981 lpDest->Value.lpszW = (LPWSTR)RELOC_PTR(lpDest->Value.lpszW);
982 if (bBadPtr)
983 ulLen = (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
984 ulCount += ulLen;
985 break;
986 case PT_BINARY:
987 lpDest->Value.bin.lpb = (LPBYTE)RELOC_PTR(lpDest->Value.bin.lpb);
988 ulCount += lpDest->Value.bin.cb;
989 break;
990 default:
991 if (lpDest->ulPropTag & MV_FLAG)
992 {
993 /* Since we have to access the array elements, don't map the
994 * array unless it is invalid (otherwise, map it at the end)
995 */
996 if (bBadPtr)
997 lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
998
999 switch (PROP_TYPE(lpProps->ulPropTag))
1000 {
1001 case PT_MV_STRING8:
1002 {
1003 ulCount += lpDest->Value.MVszA.cValues * sizeof(char *);
1004
1005 for (i = 0; i < lpDest->Value.MVszA.cValues; i++)
1006 {
1007 ULONG ulStrLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
1008
1009 lpDest->Value.MVszA.lppszA[i] = RELOC_PTR(lpDest->Value.MVszA.lppszA[i]);
1010 if (bBadPtr)
1011 ulStrLen = lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
1012 ulCount += ulStrLen;
1013 }
1014 break;
1015 }
1016 case PT_MV_UNICODE:
1017 {
1018 ulCount += lpDest->Value.MVszW.cValues * sizeof(WCHAR *);
1019
1020 for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
1021 {
1022 ULONG ulStrLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
1023
1024 lpDest->Value.MVszW.lppszW[i] = (LPWSTR)RELOC_PTR(lpDest->Value.MVszW.lppszW[i]);
1025 if (bBadPtr)
1026 ulStrLen = (lstrlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
1027 ulCount += ulStrLen;
1028 }
1029 break;
1030 }
1031 case PT_MV_BINARY:
1032 {
1033 ulCount += lpDest->Value.MVszW.cValues * sizeof(SBinary);
1034
1035 for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
1036 {
1037 lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)RELOC_PTR(lpDest->Value.MVbin.lpbin[i].lpb);
1038 ulCount += lpDest->Value.MVbin.lpbin[i].cb;
1039 }
1040 break;
1041 }
1042 default:
1043 ulCount += UlPropSize(lpDest);
1044 break;
1045 }
1046 if (!bBadPtr)
1047 lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
1048 break;
1049 }
1050 }
1051 lpDest++;
1052 }
1053 if (lpCount)
1054 *lpCount = ulCount;
1055
1056 return S_OK;
1057}
#define RELOC_PTR(p)
struct _SPropValue SPropValue

◆ 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.

678{
679 ULONG ulRet = 0;
680
681 TRACE("(%s)\n", debugstr_a(lpszStr));
682
683 if (lpszStr)
684 {
685 while (*lpszStr >= '0' && *lpszStr <= '9')
686 {
687 ulRet = ulRet * 10 + (*lpszStr - '0');
688 lpszStr++;
689 }
690 }
691 return ulRet;
692}
#define debugstr_a
Definition: kernel32.h:31

◆ UlAddRef()

ULONG WINAPI UlAddRef ( void lpUnk)

Definition at line 627 of file util.c.

628{
629 TRACE("(%p)\n", lpUnk);
630
631 if (!lpUnk)
632 return 0UL;
633 return IUnknown_AddRef((LPUNKNOWN)lpUnk);
634}
#define UL
Definition: tui.h:148

◆ UlFromSzHex()

ULONG WINAPI UlFromSzHex ( LPCSTR  )

◆ UlPropSize()

ULONG WINAPI UlPropSize ( LPSPropValue  lpProp)

Definition at line 213 of file prop.c.

214{
215 ULONG ulRet = 1u, i;
216
217 TRACE("(%p)\n", lpProp);
218
219 switch (PROP_TYPE(lpProp->ulPropTag))
220 {
221 case PT_MV_I2: ulRet = lpProp->Value.MVi.cValues;
222 /* fall through */
223 case PT_BOOLEAN:
224 case PT_I2: ulRet *= sizeof(USHORT);
225 break;
226 case PT_MV_I4: ulRet = lpProp->Value.MVl.cValues;
227 /* fall through */
228 case PT_ERROR:
229 case PT_I4: ulRet *= sizeof(LONG);
230 break;
231 case PT_MV_I8: ulRet = lpProp->Value.MVli.cValues;
232 /* fall through */
233 case PT_I8: ulRet *= sizeof(LONG64);
234 break;
235 case PT_MV_R4: ulRet = lpProp->Value.MVflt.cValues;
236 /* fall through */
237 case PT_R4: ulRet *= sizeof(float);
238 break;
239 case PT_MV_APPTIME:
240 case PT_MV_R8: ulRet = lpProp->Value.MVdbl.cValues;
241 /* fall through */
242 case PT_APPTIME:
243 case PT_R8: ulRet *= sizeof(double);
244 break;
245 case PT_MV_CURRENCY: ulRet = lpProp->Value.MVcur.cValues;
246 /* fall through */
247 case PT_CURRENCY: ulRet *= sizeof(CY);
248 break;
249 case PT_MV_SYSTIME: ulRet = lpProp->Value.MVft.cValues;
250 /* fall through */
251 case PT_SYSTIME: ulRet *= sizeof(FILETIME);
252 break;
253 case PT_MV_CLSID: ulRet = lpProp->Value.MVguid.cValues;
254 /* fall through */
255 case PT_CLSID: ulRet *= sizeof(GUID);
256 break;
257 case PT_MV_STRING8: ulRet = 0u;
258 for (i = 0; i < lpProp->Value.MVszA.cValues; i++)
259 ulRet += (lstrlenA(lpProp->Value.MVszA.lppszA[i]) + 1u);
260 break;
261 case PT_STRING8: ulRet = lstrlenA(lpProp->Value.lpszA) + 1u;
262 break;
263 case PT_MV_UNICODE: ulRet = 0u;
264 for (i = 0; i < lpProp->Value.MVszW.cValues; i++)
265 ulRet += (lstrlenW(lpProp->Value.MVszW.lppszW[i]) + 1u);
266 ulRet *= sizeof(WCHAR);
267 break;
268 case PT_UNICODE: ulRet = (lstrlenW(lpProp->Value.lpszW) + 1u) * sizeof(WCHAR);
269 break;
270 case PT_MV_BINARY: ulRet = 0u;
271 for (i = 0; i < lpProp->Value.MVbin.cValues; i++)
272 ulRet += lpProp->Value.MVbin.lpbin[i].cb;
273 break;
274 case PT_BINARY: ulRet = lpProp->Value.bin.cb;
275 break;
276 case PT_OBJECT:
277 default: ulRet = 0u;
278 break;
279 }
280
281 return ulRet;
282}
union tagCY CY
#define PT_MV_SYSTIME
Definition: mapidefs.h:258
#define PT_OBJECT
Definition: mapidefs.h:207
#define PT_MV_CURRENCY
Definition: mapidefs.h:256
#define PT_MV_I2
Definition: mapidefs.h:248
#define PT_MV_I8
Definition: mapidefs.h:263
#define PT_MV_CLSID
Definition: mapidefs.h:262
#define PT_MV_APPTIME
Definition: mapidefs.h:257
struct _FILETIME FILETIME
#define PT_MV_R4
Definition: mapidefs.h:252
#define PT_MV_I4
Definition: mapidefs.h:251
#define PT_MV_R8
Definition: mapidefs.h:255
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
static float(__cdecl *square_half_float)(float x
unsigned short USHORT
Definition: pedump.c:61
ULONG cValues
Definition: mapidefs.h:319
ULONG cValues
Definition: mapidefs.h:326
ULONG cValues
Definition: mapidefs.h:340
ULONG cValues
Definition: mapidefs.h:354
SDateTimeArray MVft
Definition: mapidefs.h:395
SRealArray MVflt
Definition: mapidefs.h:391
SGuidArray MVguid
Definition: mapidefs.h:399
SLargeIntegerArray MVli
Definition: mapidefs.h:400
SDoubleArray MVdbl
Definition: mapidefs.h:392
SCurrencyArray MVcur
Definition: mapidefs.h:393
SLongArray MVl
Definition: mapidefs.h:390

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

◆ UlRelease()

ULONG WINAPI UlRelease ( void lpUnk)

Definition at line 652 of file util.c.

653{
654 TRACE("(%p)\n", lpUnk);
655
656 if (!lpUnk)
657 return 0UL;
658 return IUnknown_Release((LPUNKNOWN)lpUnk);
659}

◆ 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.