4 * Copyright 2004 Jon Griffiths
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
31 #include "wine/list.h"
32 #include "wine/debug.h"
33 #include "wine/unicode.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(mapi
);
38 BOOL WINAPI
FBadRglpszA(LPSTR
*,ULONG
);
39 BOOL WINAPI
FBadRglpszW(LPWSTR
*,ULONG
);
41 /* Internal: Check if a property value array is invalid */
42 static inline ULONG
PROP_BadArray(LPSPropValue lpProp
, size_t elemSize
)
44 return IsBadReadPtr(lpProp
->Value
.MVi
.lpi
, lpProp
->Value
.MVi
.cValues
* elemSize
);
47 /*************************************************************************
48 * PropCopyMore@16 (MAPI32.76)
50 * Copy a property value.
53 * lpDest [O] Destination for the copied value
54 * lpSrc [I] Property value to copy to lpDest
55 * lpMore [I] Linked memory allocation function (pass MAPIAllocateMore())
56 * lpOrig [I] Original allocation to which memory will be linked
59 * Success: S_OK. lpDest contains a deep copy of lpSrc.
60 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid,
61 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
64 * Any elements within the property returned should not be individually
65 * freed, as they will be freed when lpOrig is.
67 SCODE WINAPI
PropCopyMore(LPSPropValue lpDest
, LPSPropValue lpSrc
,
68 ALLOCATEMORE
*lpMore
, LPVOID lpOrig
)
73 TRACE("(%p,%p,%p,%p)\n", lpDest
, lpSrc
, lpMore
, lpOrig
);
75 if (!lpDest
|| IsBadWritePtr(lpDest
, sizeof(SPropValue
)) ||
76 FBadProp(lpSrc
) || !lpMore
)
77 return MAPI_E_INVALID_PARAMETER
;
79 /* Shallow copy first, this is sufficient for properties without pointers */
82 switch (PROP_TYPE(lpSrc
->ulPropTag
))
85 scode
= lpMore(sizeof(GUID
), lpOrig
, (LPVOID
*)&lpDest
->Value
.lpguid
);
87 memcpy(lpDest
->Value
.lpguid
, lpSrc
->Value
.lpguid
, sizeof(GUID
));
90 ulLen
= lstrlenA(lpSrc
->Value
.lpszA
) + 1u;
91 scode
= lpMore(ulLen
, lpOrig
, (LPVOID
*)&lpDest
->Value
.lpszA
);
93 memcpy(lpDest
->Value
.lpszA
, lpSrc
->Value
.lpszA
, ulLen
);
96 ulLen
= (strlenW(lpSrc
->Value
.lpszW
) + 1u) * sizeof(WCHAR
);
97 scode
= lpMore(ulLen
, lpOrig
, (LPVOID
*)&lpDest
->Value
.lpszW
);
99 memcpy(lpDest
->Value
.lpszW
, lpSrc
->Value
.lpszW
, ulLen
);
102 scode
= lpMore(lpSrc
->Value
.bin
.cb
, lpOrig
, (LPVOID
*)&lpDest
->Value
.bin
.lpb
);
103 if (SUCCEEDED(scode
))
104 memcpy(lpDest
->Value
.bin
.lpb
, lpSrc
->Value
.bin
.lpb
, lpSrc
->Value
.bin
.cb
);
107 if (lpSrc
->ulPropTag
& MV_FLAG
)
109 ulLen
= UlPropSize(lpSrc
);
111 if (PROP_TYPE(lpSrc
->ulPropTag
) == PT_MV_STRING8
||
112 PROP_TYPE(lpSrc
->ulPropTag
) == PT_MV_UNICODE
)
114 /* UlPropSize doesn't account for the string pointers */
115 ulLen
+= lpSrc
->Value
.MVszA
.cValues
* sizeof(char*);
117 else if (PROP_TYPE(lpSrc
->ulPropTag
) == PT_MV_BINARY
)
119 /* UlPropSize doesn't account for the SBinary structs */
120 ulLen
+= lpSrc
->Value
.MVbin
.cValues
* sizeof(SBinary
);
123 lpDest
->Value
.MVi
.cValues
= lpSrc
->Value
.MVi
.cValues
;
124 scode
= lpMore(ulLen
, lpOrig
, (LPVOID
*)&lpDest
->Value
.MVi
.lpi
);
128 /* Note that we could allocate the memory for each value in a
129 * multi-value property seperately, however if an allocation failed
130 * we would be left with a bunch of allocated memory, which (while
131 * not really leaked) is unusable until lpOrig is freed. So for
132 * strings and binary arrays we make a single allocation for all
133 * of the data. This is consistent since individual elements can't
137 switch (PROP_TYPE(lpSrc
->ulPropTag
))
141 char *lpNextStr
= (char*)(lpDest
->Value
.MVszA
.lppszA
+
142 lpDest
->Value
.MVszA
.cValues
);
144 for (i
= 0; i
< lpSrc
->Value
.MVszA
.cValues
; i
++)
146 ULONG ulStrLen
= lstrlenA(lpSrc
->Value
.MVszA
.lppszA
[i
]) + 1u;
148 lpDest
->Value
.MVszA
.lppszA
[i
] = lpNextStr
;
149 memcpy(lpNextStr
, lpSrc
->Value
.MVszA
.lppszA
[i
], ulStrLen
);
150 lpNextStr
+= ulStrLen
;
156 WCHAR
*lpNextStr
= (WCHAR
*)(lpDest
->Value
.MVszW
.lppszW
+
157 lpDest
->Value
.MVszW
.cValues
);
159 for (i
= 0; i
< lpSrc
->Value
.MVszW
.cValues
; i
++)
161 ULONG ulStrLen
= strlenW(lpSrc
->Value
.MVszW
.lppszW
[i
]) + 1u;
163 lpDest
->Value
.MVszW
.lppszW
[i
] = lpNextStr
;
164 memcpy(lpNextStr
, lpSrc
->Value
.MVszW
.lppszW
[i
], ulStrLen
* sizeof(WCHAR
));
165 lpNextStr
+= ulStrLen
;
171 LPBYTE lpNext
= (LPBYTE
)(lpDest
->Value
.MVbin
.lpbin
+
172 lpDest
->Value
.MVbin
.cValues
);
174 for (i
= 0; i
< lpSrc
->Value
.MVszW
.cValues
; i
++)
176 lpDest
->Value
.MVbin
.lpbin
[i
].cb
= lpSrc
->Value
.MVbin
.lpbin
[i
].cb
;
177 lpDest
->Value
.MVbin
.lpbin
[i
].lpb
= lpNext
;
178 memcpy(lpNext
, lpSrc
->Value
.MVbin
.lpbin
[i
].lpb
, lpDest
->Value
.MVbin
.lpbin
[i
].cb
);
179 lpNext
+= lpDest
->Value
.MVbin
.lpbin
[i
].cb
;
184 /* No embedded pointers, just copy the data over */
185 memcpy(lpDest
->Value
.MVi
.lpi
, lpSrc
->Value
.MVi
.lpi
, ulLen
);
194 /*************************************************************************
195 * UlPropSize@4 (MAPI32.77)
197 * Determine the size of a property in bytes.
200 * lpProp [I] Property to determine the size of
203 * Success: The size of the value in lpProp.
204 * Failure: 0, if a multi-value (array) property is invalid or the type of lpProp
208 * - The size returned does not include the size of the SPropValue struct
209 * or the size of the array of pointers for multi-valued properties that
210 * contain pointers (such as PT_MV_STRING8 or PT-MV_UNICODE).
211 * - MSDN incorrectly states that this function returns MAPI_E_CALL_FAILED if
212 * lpProp is invalid. In reality no checking is performed and this function
213 * will crash if passed an invalid property, or return 0 if the property
214 * type is PT_OBJECT or is unknown.
216 ULONG WINAPI
UlPropSize(LPSPropValue lpProp
)
220 TRACE("(%p)\n", lpProp
);
222 switch (PROP_TYPE(lpProp
->ulPropTag
))
224 case PT_MV_I2
: ulRet
= lpProp
->Value
.MVi
.cValues
;
226 case PT_I2
: ulRet
*= sizeof(USHORT
);
228 case PT_MV_I4
: ulRet
= lpProp
->Value
.MVl
.cValues
;
230 case PT_I4
: ulRet
*= sizeof(LONG
);
232 case PT_MV_I8
: ulRet
= lpProp
->Value
.MVli
.cValues
;
233 case PT_I8
: ulRet
*= sizeof(LONG64
);
235 case PT_MV_R4
: ulRet
= lpProp
->Value
.MVflt
.cValues
;
236 case PT_R4
: ulRet
*= sizeof(float);
239 case PT_MV_R8
: ulRet
= lpProp
->Value
.MVdbl
.cValues
;
241 case PT_R8
: ulRet
*= sizeof(double);
243 case PT_MV_CURRENCY
: ulRet
= lpProp
->Value
.MVcur
.cValues
;
244 case PT_CURRENCY
: ulRet
*= sizeof(CY
);
246 case PT_MV_SYSTIME
: ulRet
= lpProp
->Value
.MVft
.cValues
;
247 case PT_SYSTIME
: ulRet
*= sizeof(FILETIME
);
249 case PT_MV_CLSID
: ulRet
= lpProp
->Value
.MVguid
.cValues
;
250 case PT_CLSID
: ulRet
*= sizeof(GUID
);
252 case PT_MV_STRING8
: ulRet
= 0u;
253 for (i
= 0; i
< lpProp
->Value
.MVszA
.cValues
; i
++)
254 ulRet
+= (lstrlenA(lpProp
->Value
.MVszA
.lppszA
[i
]) + 1u);
256 case PT_STRING8
: ulRet
= lstrlenA(lpProp
->Value
.lpszA
) + 1u;
258 case PT_MV_UNICODE
: ulRet
= 0u;
259 for (i
= 0; i
< lpProp
->Value
.MVszW
.cValues
; i
++)
260 ulRet
+= (strlenW(lpProp
->Value
.MVszW
.lppszW
[i
]) + 1u);
261 ulRet
*= sizeof(WCHAR
);
263 case PT_UNICODE
: ulRet
= (lstrlenW(lpProp
->Value
.lpszW
) + 1u) * sizeof(WCHAR
);
265 case PT_MV_BINARY
: ulRet
= 0u;
266 for (i
= 0; i
< lpProp
->Value
.MVbin
.cValues
; i
++)
267 ulRet
+= lpProp
->Value
.MVbin
.lpbin
[i
].cb
;
269 case PT_BINARY
: ulRet
= lpProp
->Value
.bin
.cb
;
280 /*************************************************************************
281 * FPropContainsProp@12 (MAPI32.78)
283 * Find a property with a given property tag in a property array.
286 * lpHaystack [I] Property to match to
287 * lpNeedle [I] Property to find in lpHaystack
288 * ulFuzzy [I] Flags controlling match type and strictness (FL_* flags from "mapidefs.h")
291 * TRUE, if lpNeedle matches lpHaystack according to the criteria of ulFuzzy.
294 * Only property types of PT_STRING8 and PT_BINARY are handled by this function.
296 BOOL WINAPI
FPropContainsProp(LPSPropValue lpHaystack
, LPSPropValue lpNeedle
, ULONG ulFuzzy
)
298 TRACE("(%p,%p,0x%08lx)\n", lpHaystack
, lpNeedle
, ulFuzzy
);
300 if (FBadProp(lpHaystack
) || FBadProp(lpNeedle
) ||
301 PROP_TYPE(lpHaystack
->ulPropTag
) != PROP_TYPE(lpNeedle
->ulPropTag
))
304 /* FIXME: Do later versions support Unicode as well? */
306 if (PROP_TYPE(lpHaystack
->ulPropTag
) == PT_STRING8
)
308 DWORD dwFlags
= 0, dwNeedleLen
, dwHaystackLen
;
310 if (ulFuzzy
& FL_IGNORECASE
)
311 dwFlags
|= NORM_IGNORECASE
;
312 if (ulFuzzy
& FL_IGNORENONSPACE
)
313 dwFlags
|= NORM_IGNORENONSPACE
;
314 if (ulFuzzy
& FL_LOOSE
)
315 dwFlags
|= (NORM_IGNORECASE
|NORM_IGNORENONSPACE
|NORM_IGNORESYMBOLS
);
317 dwNeedleLen
= lstrlenA(lpNeedle
->Value
.lpszA
);
318 dwHaystackLen
= lstrlenA(lpHaystack
->Value
.lpszA
);
320 if ((ulFuzzy
& (FL_SUBSTRING
|FL_PREFIX
)) == FL_PREFIX
)
322 if (dwNeedleLen
<= dwHaystackLen
&&
323 CompareStringA(LOCALE_USER_DEFAULT
, dwFlags
,
324 lpHaystack
->Value
.lpszA
, dwNeedleLen
,
325 lpNeedle
->Value
.lpszA
, dwNeedleLen
) == CSTR_EQUAL
)
326 return TRUE
; /* needle is a prefix of haystack */
328 else if ((ulFuzzy
& (FL_SUBSTRING
|FL_PREFIX
)) == FL_SUBSTRING
)
330 LPSTR (WINAPI
*pStrChrFn
)(LPCSTR
,WORD
) = StrChrA
;
331 LPSTR lpStr
= lpHaystack
->Value
.lpszA
;
333 if (dwFlags
& NORM_IGNORECASE
)
334 pStrChrFn
= StrChrIA
;
336 while ((lpStr
= pStrChrFn(lpStr
, *lpNeedle
->Value
.lpszA
)) != NULL
)
338 dwHaystackLen
-= (lpStr
- lpHaystack
->Value
.lpszA
);
339 if (dwNeedleLen
<= dwHaystackLen
&&
340 CompareStringA(LOCALE_USER_DEFAULT
, dwFlags
,
342 lpNeedle
->Value
.lpszA
, dwNeedleLen
) == CSTR_EQUAL
)
343 return TRUE
; /* needle is a substring of haystack */
347 else if (CompareStringA(LOCALE_USER_DEFAULT
, dwFlags
,
348 lpHaystack
->Value
.lpszA
, dwHaystackLen
,
349 lpNeedle
->Value
.lpszA
, dwNeedleLen
) == CSTR_EQUAL
)
350 return TRUE
; /* full string match */
352 else if (PROP_TYPE(lpHaystack
->ulPropTag
) == PT_BINARY
)
354 if ((ulFuzzy
& (FL_SUBSTRING
|FL_PREFIX
)) == FL_PREFIX
)
356 if (lpNeedle
->Value
.bin
.cb
<= lpHaystack
->Value
.bin
.cb
&&
357 !memcmp(lpNeedle
->Value
.bin
.lpb
, lpHaystack
->Value
.bin
.lpb
,
358 lpNeedle
->Value
.bin
.cb
))
359 return TRUE
; /* needle is a prefix of haystack */
361 else if ((ulFuzzy
& (FL_SUBSTRING
|FL_PREFIX
)) == FL_SUBSTRING
)
363 ULONG ulLen
= lpHaystack
->Value
.bin
.cb
;
364 LPBYTE lpb
= lpHaystack
->Value
.bin
.lpb
;
366 while ((lpb
= memchr(lpb
, *lpNeedle
->Value
.bin
.lpb
, ulLen
)) != NULL
)
368 ulLen
= lpHaystack
->Value
.bin
.cb
- (lpb
- lpHaystack
->Value
.bin
.lpb
);
369 if (lpNeedle
->Value
.bin
.cb
<= ulLen
&&
370 !memcmp(lpNeedle
->Value
.bin
.lpb
, lpb
, lpNeedle
->Value
.bin
.cb
))
371 return TRUE
; /* needle is a substring of haystack */
375 else if (!LPropCompareProp(lpHaystack
, lpNeedle
))
376 return TRUE
; /* needle is an exact match with haystack */
382 /*************************************************************************
383 * FPropCompareProp@12 (MAPI32.79)
385 * Compare two properties.
388 * lpPropLeft [I] Left hand property to compare to lpPropRight
389 * ulOp [I] Comparison operator (RELOP_* enum from "mapidefs.h")
390 * lpPropRight [I] Right hand property to compare to lpPropLeft
393 * TRUE, if the comparison is true, FALSE otherwise.
395 BOOL WINAPI
FPropCompareProp(LPSPropValue lpPropLeft
, ULONG ulOp
, LPSPropValue lpPropRight
)
399 TRACE("(%p,%ld,%p)\n", lpPropLeft
, ulOp
, lpPropRight
);
401 if (ulOp
> RELOP_RE
|| FBadProp(lpPropLeft
) || FBadProp(lpPropRight
))
404 if (ulOp
== RELOP_RE
)
406 FIXME("Comparison operator RELOP_RE not yet implemented!\n");
410 iCmp
= LPropCompareProp(lpPropLeft
, lpPropRight
);
414 case RELOP_LT
: return iCmp
< 0 ? TRUE
: FALSE
;
415 case RELOP_LE
: return iCmp
<= 0 ? TRUE
: FALSE
;
416 case RELOP_GT
: return iCmp
> 0 ? TRUE
: FALSE
;
417 case RELOP_GE
: return iCmp
>= 0 ? TRUE
: FALSE
;
418 case RELOP_EQ
: return iCmp
== 0 ? TRUE
: FALSE
;
419 case RELOP_NE
: return iCmp
!= 0 ? TRUE
: FALSE
;
424 /*************************************************************************
425 * LPropCompareProp@8 (MAPI32.80)
427 * Compare two properties.
430 * lpPropLeft [I] Left hand property to compare to lpPropRight
431 * lpPropRight [I] Right hand property to compare to lpPropLeft
434 * An integer less than, equal to or greater than 0, indicating that
435 * lpszStr is less than, the same, or greater than lpszComp.
437 LONG WINAPI
LPropCompareProp(LPSPropValue lpPropLeft
, LPSPropValue lpPropRight
)
441 TRACE("(%p->0x%08lx,%p->0x%08lx)\n", lpPropLeft
, lpPropLeft
->ulPropTag
,
442 lpPropRight
, lpPropRight
->ulPropTag
);
444 /* If the properties are not the same, sort by property type */
445 if (PROP_TYPE(lpPropLeft
->ulPropTag
) != PROP_TYPE(lpPropRight
->ulPropTag
))
446 return (LONG
)PROP_TYPE(lpPropLeft
->ulPropTag
) - (LONG
)PROP_TYPE(lpPropRight
->ulPropTag
);
448 switch (PROP_TYPE(lpPropLeft
->ulPropTag
))
452 return 0; /* NULLs are equal */
454 return lpPropLeft
->Value
.i
- lpPropRight
->Value
.i
;
456 return lpPropLeft
->Value
.l
- lpPropRight
->Value
.l
;
458 if (lpPropLeft
->Value
.li
.QuadPart
> lpPropRight
->Value
.li
.QuadPart
)
460 if (lpPropLeft
->Value
.li
.QuadPart
== lpPropRight
->Value
.li
.QuadPart
)
464 if (lpPropLeft
->Value
.flt
> lpPropRight
->Value
.flt
)
466 if (lpPropLeft
->Value
.flt
== lpPropRight
->Value
.flt
)
471 if (lpPropLeft
->Value
.dbl
> lpPropRight
->Value
.dbl
)
473 if (lpPropLeft
->Value
.dbl
== lpPropRight
->Value
.dbl
)
477 if (lpPropLeft
->Value
.cur
.int64
> lpPropRight
->Value
.cur
.int64
)
479 if (lpPropLeft
->Value
.cur
.int64
== lpPropRight
->Value
.cur
.int64
)
483 return CompareFileTime(&lpPropLeft
->Value
.ft
, &lpPropRight
->Value
.ft
);
485 return (lpPropLeft
->Value
.b
? 1 : 0) - (lpPropRight
->Value
.b
? 1 : 0);
487 if (lpPropLeft
->Value
.bin
.cb
== lpPropRight
->Value
.bin
.cb
)
488 iRet
= memcmp(lpPropLeft
->Value
.bin
.lpb
, lpPropRight
->Value
.bin
.lpb
,
489 lpPropLeft
->Value
.bin
.cb
);
492 iRet
= memcmp(lpPropLeft
->Value
.bin
.lpb
, lpPropRight
->Value
.bin
.lpb
,
493 min(lpPropLeft
->Value
.bin
.cb
, lpPropRight
->Value
.bin
.cb
));
496 iRet
= lpPropLeft
->Value
.bin
.cb
- lpPropRight
->Value
.bin
.cb
;
500 return lstrcmpA(lpPropLeft
->Value
.lpszA
, lpPropRight
->Value
.lpszA
);
502 return strcmpW(lpPropLeft
->Value
.lpszW
, lpPropRight
->Value
.lpszW
);
504 if (lpPropLeft
->Value
.err
> lpPropRight
->Value
.err
)
506 if (lpPropLeft
->Value
.err
== lpPropRight
->Value
.err
)
510 return memcmp(lpPropLeft
->Value
.lpguid
, lpPropRight
->Value
.lpguid
,
513 FIXME("Unhandled property type %ld", PROP_TYPE(lpPropLeft
->ulPropTag
));
517 /*************************************************************************
518 * HrGetOneProp@8 (MAPI32.135)
520 * Get a property value from an IMAPIProp object.
523 * lpIProp [I] IMAPIProp object to get the property value in
524 * ulPropTag [I] Property tag of the property to get
525 * lppProp [O] Destination for the returned property
528 * Success: S_OK. *lppProp contains the property value requested.
529 * Failure: MAPI_E_NOT_FOUND, if no property value has the tag given by ulPropTag.
531 HRESULT WINAPI
HrGetOneProp(LPMAPIPROP lpIProp
, ULONG ulPropTag
, LPSPropValue
*lppProp
)
537 TRACE("(%p,%ld,%p)\n", lpIProp
, ulPropTag
, lppProp
);
540 pta
.aulPropTag
[0] = ulPropTag
;
541 hRet
= IMAPIProp_GetProps(lpIProp
, &pta
, 0u, &ulCount
, lppProp
);
542 if (hRet
== MAPI_W_ERRORS_RETURNED
)
544 MAPIFreeBuffer(*lppProp
);
546 hRet
= MAPI_E_NOT_FOUND
;
551 /*************************************************************************
552 * HrSetOneProp@8 (MAPI32.136)
554 * Set a property value in an IMAPIProp object.
557 * lpIProp [I] IMAPIProp object to set the property value in
558 * lpProp [I] Property value to set
561 * Success: S_OK. The value in lpProp is set in lpIProp.
562 * Failure: An error result from IMAPIProp_SetProps().
564 HRESULT WINAPI
HrSetOneProp(LPMAPIPROP lpIProp
, LPSPropValue lpProp
)
566 TRACE("(%p,%p)\n", lpIProp
, lpProp
);
568 return IMAPIProp_SetProps(lpIProp
, 1u, lpProp
, NULL
);
571 /*************************************************************************
572 * FPropExists@8 (MAPI32.137)
574 * Find a property with a given property tag in an IMAPIProp object.
577 * lpIProp [I] IMAPIProp object to find the property tag in
578 * ulPropTag [I] Property tag to find
581 * TRUE, if ulPropTag matches a property held in lpIProp,
585 * if ulPropTag has a property type of PT_UNSPECIFIED, then only the property
586 * Ids need to match for a successful match to occur.
588 BOOL WINAPI
FPropExists(LPMAPIPROP lpIProp
, ULONG ulPropTag
)
592 TRACE("(%p,%ld)\n", lpIProp
, ulPropTag
);
596 LPSPropTagArray lpTags
;
599 if (FAILED(IMAPIProp_GetPropList(lpIProp
, 0u, &lpTags
)))
602 for (i
= 0; i
< lpTags
->cValues
; i
++)
604 if (!FBadPropTag(lpTags
->aulPropTag
[i
]) &&
605 (lpTags
->aulPropTag
[i
] == ulPropTag
||
606 (PROP_TYPE(ulPropTag
) == PT_UNSPECIFIED
&&
607 PROP_ID(lpTags
->aulPropTag
[i
]) == lpTags
->aulPropTag
[i
])))
613 MAPIFreeBuffer(lpTags
);
618 /*************************************************************************
619 * PpropFindProp@12 (MAPI32.138)
621 * Find a property with a given property tag in a property array.
624 * lpProps [I] Property array to search
625 * cValues [I] Number of properties in lpProps
626 * ulPropTag [I] Property tag to find
629 * A pointer to the matching property, or NULL if none was found.
632 * if ulPropTag has a property type of PT_UNSPECIFIED, then only the property
633 * Ids need to match for a successful match to occur.
635 LPSPropValue WINAPI
PpropFindProp(LPSPropValue lpProps
, ULONG cValues
, ULONG ulPropTag
)
637 TRACE("(%p,%ld,%ld)\n", lpProps
, cValues
, ulPropTag
);
639 if (lpProps
&& cValues
)
642 for (i
= 0; i
< cValues
; i
++)
644 if (!FBadPropTag(lpProps
[i
].ulPropTag
) &&
645 (lpProps
[i
].ulPropTag
== ulPropTag
||
646 (PROP_TYPE(ulPropTag
) == PT_UNSPECIFIED
&&
647 PROP_ID(lpProps
[i
].ulPropTag
) == PROP_ID(ulPropTag
))))
654 /*************************************************************************
655 * FreePadrlist@4 (MAPI32.139)
657 * Free the memory used by an address book list.
660 * lpAddrs [I] Address book list to free
665 VOID WINAPI
FreePadrlist(LPADRLIST lpAddrs
)
667 TRACE("(%p)\n", lpAddrs
);
669 /* Structures are binary compatible; use the same implementation */
670 return FreeProws((LPSRowSet
)lpAddrs
);
673 /*************************************************************************
674 * FreeProws@4 (MAPI32.140)
676 * Free the memory used by a row set.
679 * lpRowSet [I] Row set to free
684 VOID WINAPI
FreeProws(LPSRowSet lpRowSet
)
686 TRACE("(%p)\n", lpRowSet
);
692 for (i
= 0; i
< lpRowSet
->cRows
; i
++)
693 MAPIFreeBuffer(lpRowSet
->aRow
[i
].lpProps
);
695 MAPIFreeBuffer(lpRowSet
);
699 /*************************************************************************
700 * ScCountProps@12 (MAPI32.170)
702 * Validate and determine the length of an array of properties.
705 * iCount [I] Length of the lpProps array
706 * lpProps [I] Array of properties to validate/size
707 * pcBytes [O] If non-NULL, destination for the size of the property array
710 * Success: S_OK. If pcBytes is non-NULL, it contains the size of the propery array.
711 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid or validation
712 * of the property array fails.
714 SCODE WINAPI
ScCountProps(INT iCount
, LPSPropValue lpProps
, ULONG
*pcBytes
)
716 ULONG i
, ulCount
= iCount
, ulBytes
= 0;
718 TRACE("(%d,%p,%p)\n", iCount
, lpProps
, pcBytes
);
720 if (iCount
<= 0 || !lpProps
||
721 IsBadReadPtr(lpProps
, iCount
* sizeof(SPropValue
)))
722 return MAPI_E_INVALID_PARAMETER
;
724 for (i
= 0; i
< ulCount
; i
++)
726 ULONG ulPropSize
= 0;
728 if (FBadProp(&lpProps
[i
]) || lpProps
[i
].ulPropTag
== PROP_ID_NULL
||
729 lpProps
[i
].ulPropTag
== PROP_ID_INVALID
)
730 return MAPI_E_INVALID_PARAMETER
;
732 if (PROP_TYPE(lpProps
[i
].ulPropTag
) != PT_OBJECT
)
734 ulPropSize
= UlPropSize(&lpProps
[i
]);
736 return MAPI_E_INVALID_PARAMETER
;
739 switch (PROP_TYPE(lpProps
[i
].ulPropTag
))
753 ulPropSize
+= sizeof(SPropValue
);
756 ulPropSize
+= lpProps
[i
].Value
.MVszA
.cValues
* sizeof(char*) + sizeof(SPropValue
);
760 ulPropSize
+= lpProps
[i
].Value
.MVszA
.cValues
* sizeof(char*) + sizeof(SPropValue
);
763 ulPropSize
+= lpProps
[i
].Value
.MVbin
.cValues
* sizeof(SBinary
) + sizeof(SPropValue
);
766 ulPropSize
= sizeof(SPropValue
);
769 ulBytes
+= ulPropSize
;
777 /*************************************************************************
778 * ScCopyProps@16 (MAPI32.171)
780 * Copy an array of property values into a buffer suited for serialisation.
783 * cValues [I] Number of properties in lpProps
784 * lpProps [I] Property array to copy
785 * lpDst [O] Destination for the serialised data
786 * lpCount [O] If non-NULL, destination for the number of bytes of data written to lpDst
789 * Success: S_OK. lpDst contains the serialised data from lpProps.
790 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
793 * The resulting property value array is stored in a contigous block starting at lpDst.
795 SCODE WINAPI
ScCopyProps(int cValues
, LPSPropValue lpProps
, LPVOID lpDst
, ULONG
*lpCount
)
797 LPSPropValue lpDest
= (LPSPropValue
)lpDst
;
798 char *lpDataDest
= (char *)(lpDest
+ cValues
);
799 ULONG ulLen
, i
, iter
;
801 TRACE("(%d,%p,%p,%p)\n", cValues
, lpProps
, lpDst
, lpCount
);
803 if (!lpProps
|| cValues
< 0 || !lpDest
)
804 return MAPI_E_INVALID_PARAMETER
;
806 memcpy(lpDst
, lpProps
, cValues
* sizeof(SPropValue
));
808 for (iter
= 0; iter
< cValues
; iter
++)
810 switch (PROP_TYPE(lpProps
->ulPropTag
))
813 lpDest
->Value
.lpguid
= (LPGUID
)lpDataDest
;
814 memcpy(lpDest
->Value
.lpguid
, lpProps
->Value
.lpguid
, sizeof(GUID
));
815 lpDataDest
+= sizeof(GUID
);
818 ulLen
= lstrlenA(lpProps
->Value
.lpszA
) + 1u;
819 lpDest
->Value
.lpszA
= lpDataDest
;
820 memcpy(lpDest
->Value
.lpszA
, lpProps
->Value
.lpszA
, ulLen
);
824 ulLen
= (strlenW(lpProps
->Value
.lpszW
) + 1u) * sizeof(WCHAR
);
825 lpDest
->Value
.lpszW
= (LPWSTR
)lpDataDest
;
826 memcpy(lpDest
->Value
.lpszW
, lpProps
->Value
.lpszW
, ulLen
);
830 lpDest
->Value
.bin
.lpb
= (LPBYTE
)lpDataDest
;
831 memcpy(lpDest
->Value
.bin
.lpb
, lpProps
->Value
.bin
.lpb
, lpProps
->Value
.bin
.cb
);
832 lpDataDest
+= lpProps
->Value
.bin
.cb
;
835 if (lpProps
->ulPropTag
& MV_FLAG
)
837 lpDest
->Value
.MVi
.cValues
= lpProps
->Value
.MVi
.cValues
;
838 /* Note: Assignment uses lppszA but covers all cases by union aliasing */
839 lpDest
->Value
.MVszA
.lppszA
= (char**)lpDataDest
;
841 switch (PROP_TYPE(lpProps
->ulPropTag
))
845 lpDataDest
+= lpProps
->Value
.MVszA
.cValues
* sizeof(char *);
847 for (i
= 0; i
< lpProps
->Value
.MVszA
.cValues
; i
++)
849 ULONG ulStrLen
= lstrlenA(lpProps
->Value
.MVszA
.lppszA
[i
]) + 1u;
851 lpDest
->Value
.MVszA
.lppszA
[i
] = lpDataDest
;
852 memcpy(lpDataDest
, lpProps
->Value
.MVszA
.lppszA
[i
], ulStrLen
);
853 lpDataDest
+= ulStrLen
;
859 lpDataDest
+= lpProps
->Value
.MVszW
.cValues
* sizeof(WCHAR
*);
861 for (i
= 0; i
< lpProps
->Value
.MVszW
.cValues
; i
++)
863 ULONG ulStrLen
= (strlenW(lpProps
->Value
.MVszW
.lppszW
[i
]) + 1u) * sizeof(WCHAR
);
865 lpDest
->Value
.MVszW
.lppszW
[i
] = (LPWSTR
)lpDataDest
;
866 memcpy(lpDataDest
, lpProps
->Value
.MVszW
.lppszW
[i
], ulStrLen
);
867 lpDataDest
+= ulStrLen
;
873 lpDataDest
+= lpProps
->Value
.MVszW
.cValues
* sizeof(SBinary
);
875 for (i
= 0; i
< lpProps
->Value
.MVszW
.cValues
; i
++)
877 lpDest
->Value
.MVbin
.lpbin
[i
].cb
= lpProps
->Value
.MVbin
.lpbin
[i
].cb
;
878 lpDest
->Value
.MVbin
.lpbin
[i
].lpb
= (LPBYTE
)lpDataDest
;
879 memcpy(lpDataDest
, lpProps
->Value
.MVbin
.lpbin
[i
].lpb
, lpDest
->Value
.MVbin
.lpbin
[i
].cb
);
880 lpDataDest
+= lpDest
->Value
.MVbin
.lpbin
[i
].cb
;
885 /* No embedded pointers, just copy the data over */
886 ulLen
= UlPropSize(lpProps
);
887 memcpy(lpDest
->Value
.MVi
.lpi
, lpProps
->Value
.MVi
.lpi
, ulLen
);
898 *lpCount
= lpDataDest
- (char *)lpDst
;
903 /*************************************************************************
904 * ScRelocProps@20 (MAPI32.172)
906 * Relocate the pointers in an array of property values after it has been copied.
909 * cValues [I] Number of properties in lpProps
910 * lpProps [O] Property array to relocate the pointers in.
911 * lpOld [I] Position where the data was copied from
912 * lpNew [I] Position where the data was copied to
913 * lpCount [O] If non-NULL, destination for the number of bytes of data at lpDst
916 * Success: S_OK. Any pointers in lpProps are relocated.
917 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
920 * MSDN states that this function can be used for serialisation by passing
921 * NULL as either lpOld or lpNew, thus converting any pointers in lpProps
922 * between offsets and pointers. This does not work in native (it crashes),
923 * and cannot be made to work in Wine because the original interface design
924 * is deficient. The only use left for this function is to remap pointers
925 * in a contigous property array that has been copied with memcpy() to another
928 SCODE WINAPI
ScRelocProps(int cValues
, LPSPropValue lpProps
, LPVOID lpOld
,
929 LPVOID lpNew
, ULONG
*lpCount
)
931 static const BOOL bBadPtr
= TRUE
; /* Windows bug - Assumes source is bad */
932 LPSPropValue lpDest
= (LPSPropValue
)lpProps
;
933 ULONG ulCount
= cValues
* sizeof(SPropValue
);
934 ULONG ulLen
, i
, iter
;
936 TRACE("(%d,%p,%p,%p,%p)\n", cValues
, lpProps
, lpOld
, lpNew
, lpCount
);
938 if (!lpProps
|| cValues
< 0 || !lpOld
|| !lpNew
)
939 return MAPI_E_INVALID_PARAMETER
;
941 /* The reason native doesn't work as MSDN states is that it assumes that
942 * the lpProps pointer contains valid pointers. This is obviously not
943 * true if the array is being read back from serialisation (the pointers
944 * are just offsets). Native can't actually work converting the pointers to
945 * offsets either, because it converts any array pointers to offsets then
946 * _dereferences the offset_ in order to convert the array elements!
948 * The code below would handle both cases except that the design of this
949 * function makes it impossible to know when the pointers in lpProps are
950 * valid. If both lpOld and lpNew are non-NULL, native reads the pointers
951 * after converting them, so we must do the same. Its seems this
952 * functionality was never tested by MS.
955 #define RELOC_PTR(p) (((char*)(p)) - (char*)lpOld + (char*)lpNew)
957 for (iter
= 0; iter
< cValues
; iter
++)
959 switch (PROP_TYPE(lpDest
->ulPropTag
))
962 lpDest
->Value
.lpguid
= (LPGUID
)RELOC_PTR(lpDest
->Value
.lpguid
);
963 ulCount
+= sizeof(GUID
);
966 ulLen
= bBadPtr
? 0 : lstrlenA(lpDest
->Value
.lpszA
) + 1u;
967 lpDest
->Value
.lpszA
= (LPSTR
)RELOC_PTR(lpDest
->Value
.lpszA
);
969 ulLen
= lstrlenA(lpDest
->Value
.lpszA
) + 1u;
973 ulLen
= bBadPtr
? 0 : (lstrlenW(lpDest
->Value
.lpszW
) + 1u) * sizeof(WCHAR
);
974 lpDest
->Value
.lpszW
= (LPWSTR
)RELOC_PTR(lpDest
->Value
.lpszW
);
976 ulLen
= (strlenW(lpDest
->Value
.lpszW
) + 1u) * sizeof(WCHAR
);
980 lpDest
->Value
.bin
.lpb
= (LPBYTE
)RELOC_PTR(lpDest
->Value
.bin
.lpb
);
981 ulCount
+= lpDest
->Value
.bin
.cb
;
984 if (lpDest
->ulPropTag
& MV_FLAG
)
986 /* Since we have to access the array elements, don't map the
987 * array unless it is invalid (otherwise, map it at the end)
990 lpDest
->Value
.MVszA
.lppszA
= (LPSTR
*)RELOC_PTR(lpDest
->Value
.MVszA
.lppszA
);
992 switch (PROP_TYPE(lpProps
->ulPropTag
))
996 ulCount
+= lpDest
->Value
.MVszA
.cValues
* sizeof(char *);
998 for (i
= 0; i
< lpDest
->Value
.MVszA
.cValues
; i
++)
1000 ULONG ulStrLen
= bBadPtr
? 0 : lstrlenA(lpDest
->Value
.MVszA
.lppszA
[i
]) + 1u;
1002 lpDest
->Value
.MVszA
.lppszA
[i
] = (LPSTR
)RELOC_PTR(lpDest
->Value
.MVszA
.lppszA
[i
]);
1004 ulStrLen
= lstrlenA(lpDest
->Value
.MVszA
.lppszA
[i
]) + 1u;
1005 ulCount
+= ulStrLen
;
1011 ulCount
+= lpDest
->Value
.MVszW
.cValues
* sizeof(WCHAR
*);
1013 for (i
= 0; i
< lpDest
->Value
.MVszW
.cValues
; i
++)
1015 ULONG ulStrLen
= bBadPtr
? 0 : (strlenW(lpDest
->Value
.MVszW
.lppszW
[i
]) + 1u) * sizeof(WCHAR
);
1017 lpDest
->Value
.MVszW
.lppszW
[i
] = (LPWSTR
)RELOC_PTR(lpDest
->Value
.MVszW
.lppszW
[i
]);
1019 ulStrLen
= (strlenW(lpDest
->Value
.MVszW
.lppszW
[i
]) + 1u) * sizeof(WCHAR
);
1020 ulCount
+= ulStrLen
;
1026 ulCount
+= lpDest
->Value
.MVszW
.cValues
* sizeof(SBinary
);
1028 for (i
= 0; i
< lpDest
->Value
.MVszW
.cValues
; i
++)
1030 lpDest
->Value
.MVbin
.lpbin
[i
].lpb
= (LPBYTE
)RELOC_PTR(lpDest
->Value
.MVbin
.lpbin
[i
].lpb
);
1031 ulCount
+= lpDest
->Value
.MVbin
.lpbin
[i
].cb
;
1036 ulCount
+= UlPropSize(lpDest
);
1040 lpDest
->Value
.MVszA
.lppszA
= (LPSTR
*)RELOC_PTR(lpDest
->Value
.MVszA
.lppszA
);
1052 /*************************************************************************
1053 * LpValFindProp@12 (MAPI32.173)
1055 * Find a property with a given property id in a property array.
1058 * ulPropTag [I] Property tag containing property id to find
1059 * cValues [I] Number of properties in lpProps
1060 * lpProps [I] Property array to search
1063 * A pointer to the matching property, or NULL if none was found.
1066 * This function matches only on the property id and does not care if the
1067 * property types differ.
1069 LPSPropValue WINAPI
LpValFindProp(ULONG ulPropTag
, ULONG cValues
, LPSPropValue lpProps
)
1071 TRACE("(%ld,%ld,%p)\n", ulPropTag
, cValues
, lpProps
);
1073 if (lpProps
&& cValues
)
1076 for (i
= 0; i
< cValues
; i
++)
1078 if (PROP_ID(ulPropTag
) == PROP_ID(lpProps
[i
].ulPropTag
))
1085 /*************************************************************************
1086 * ScDupPropset@16 (MAPI32.174)
1088 * Duplicate a property value array into a contigous block of memory.
1091 * cValues [I] Number of properties in lpProps
1092 * lpProps [I] Property array to duplicate
1093 * lpAlloc [I] Memory allocation function, use MAPIAllocateBuffer()
1094 * lpNewProp [O] Destination for the newly duplicated property value array
1097 * Success: S_OK. *lpNewProp contains the duplicated array.
1098 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid,
1099 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
1101 SCODE WINAPI
ScDupPropset(int cValues
, LPSPropValue lpProps
,
1102 LPALLOCATEBUFFER lpAlloc
, LPSPropValue
*lpNewProp
)
1107 TRACE("(%d,%p,%p,%p)\n", cValues
, lpProps
, lpAlloc
, lpNewProp
);
1109 sc
= ScCountProps(cValues
, lpProps
, &ulCount
);
1112 sc
= lpAlloc(ulCount
, (LPVOID
*)lpNewProp
);
1114 sc
= ScCopyProps(cValues
, lpProps
, *lpNewProp
, &ulCount
);
1119 /*************************************************************************
1120 * FBadRglpszA@8 (MAPI32.175)
1122 * Determine if an array of strings is invalid
1125 * lppszStrs [I] Array of strings to check
1126 * ulCount [I] Number of strings in lppszStrs
1129 * TRUE, if lppszStrs is invalid, FALSE otherwise.
1131 BOOL WINAPI
FBadRglpszA(LPSTR
*lppszStrs
, ULONG ulCount
)
1135 TRACE("(%p,%ld)\n", lppszStrs
, ulCount
);
1140 if (!lppszStrs
|| IsBadReadPtr(lppszStrs
, ulCount
* sizeof(LPWSTR
)))
1143 for (i
= 0; i
< ulCount
; i
++)
1145 if (!lppszStrs
[i
] || IsBadStringPtrA(lppszStrs
[i
], -1))
1151 /*************************************************************************
1152 * FBadRglpszW@8 (MAPI32.176)
1156 BOOL WINAPI
FBadRglpszW(LPWSTR
*lppszStrs
, ULONG ulCount
)
1160 TRACE("(%p,%ld)\n", lppszStrs
, ulCount
);
1165 if (!lppszStrs
|| IsBadReadPtr(lppszStrs
, ulCount
* sizeof(LPWSTR
)))
1168 for (i
= 0; i
< ulCount
; i
++)
1170 if (!lppszStrs
[i
] || IsBadStringPtrW(lppszStrs
[i
], -1))
1176 /*************************************************************************
1177 * FBadRowSet@4 (MAPI32.177)
1179 * Determine if a row is invalid
1182 * lpRow [I] Row to check
1185 * TRUE, if lpRow is invalid, FALSE otherwise.
1187 BOOL WINAPI
FBadRowSet(LPSRowSet lpRowSet
)
1190 TRACE("(%p)\n", lpRowSet
);
1192 if (!lpRowSet
|| IsBadReadPtr(lpRowSet
, CbSRowSet(lpRowSet
)))
1195 for (i
= 0; i
< lpRowSet
->cRows
; i
++)
1197 if (FBadRow(&lpRowSet
->aRow
[i
]))
1203 /*************************************************************************
1204 * FBadPropTag@4 (MAPI32.179)
1206 * Determine if a property tag is invalid
1209 * ulPropTag [I] Property tag to check
1212 * TRUE, if ulPropTag is invalid, FALSE otherwise.
1214 ULONG WINAPI
FBadPropTag(ULONG ulPropTag
)
1216 TRACE("(0x%08lx)\n", ulPropTag
);
1218 switch (ulPropTag
& (~MV_FLAG
& PROP_TYPE_MASK
))
1220 case PT_UNSPECIFIED
:
1242 /*************************************************************************
1243 * FBadRow@4 (MAPI32.180)
1245 * Determine if a row is invalid
1248 * lpRow [I] Row to check
1251 * TRUE, if lpRow is invalid, FALSE otherwise.
1253 ULONG WINAPI
FBadRow(LPSRow lpRow
)
1256 TRACE("(%p)\n", lpRow
);
1258 if (!lpRow
|| IsBadReadPtr(lpRow
, sizeof(SRow
)) || !lpRow
->lpProps
||
1259 IsBadReadPtr(lpRow
->lpProps
, lpRow
->cValues
* sizeof(SPropValue
)))
1262 for (i
= 0; i
< lpRow
->cValues
; i
++)
1264 if (FBadProp(&lpRow
->lpProps
[i
]))
1270 /*************************************************************************
1271 * FBadProp@4 (MAPI32.181)
1273 * Determine if a property is invalid
1276 * lpProp [I] Property to check
1279 * TRUE, if lpProp is invalid, FALSE otherwise.
1281 ULONG WINAPI
FBadProp(LPSPropValue lpProp
)
1283 if (!lpProp
|| IsBadReadPtr(lpProp
, sizeof(SPropValue
)) ||
1284 FBadPropTag(lpProp
->ulPropTag
))
1287 switch (PROP_TYPE(lpProp
->ulPropTag
))
1289 /* Single value properties containing pointers */
1291 if (!lpProp
->Value
.lpszA
|| IsBadStringPtrA(lpProp
->Value
.lpszA
, -1))
1295 if (!lpProp
->Value
.lpszW
|| IsBadStringPtrW(lpProp
->Value
.lpszW
, -1))
1299 if (IsBadReadPtr(lpProp
->Value
.bin
.lpb
, lpProp
->Value
.bin
.cb
))
1303 if (IsBadReadPtr(lpProp
->Value
.lpguid
, sizeof(GUID
)))
1307 /* Multiple value properties (arrays) containing no pointers */
1309 return PROP_BadArray(lpProp
, sizeof(SHORT
));
1311 return PROP_BadArray(lpProp
, sizeof(LONG
));
1312 case PT_MV_LONGLONG
:
1313 return PROP_BadArray(lpProp
, sizeof(LONG64
));
1315 return PROP_BadArray(lpProp
, sizeof(float));
1317 return PROP_BadArray(lpProp
, sizeof(FILETIME
));
1320 return PROP_BadArray(lpProp
, sizeof(double));
1321 case PT_MV_CURRENCY
:
1322 return PROP_BadArray(lpProp
, sizeof(CY
));
1324 return PROP_BadArray(lpProp
, sizeof(GUID
));
1326 /* Multiple value properties containing pointers */
1328 return FBadRglpszA(lpProp
->Value
.MVszA
.lppszA
,
1329 lpProp
->Value
.MVszA
.cValues
);
1331 return FBadRglpszW(lpProp
->Value
.MVszW
.lppszW
,
1332 lpProp
->Value
.MVszW
.cValues
);
1334 return FBadEntryList((LPENTRYLIST
)&lpProp
->Value
.MVbin
);
1339 /*************************************************************************
1340 * FBadColumnSet@4 (MAPI32.182)
1342 * Determine if an array of property tags is invalid
1345 * lpCols [I] Property tag array to check
1348 * TRUE, if lpCols is invalid, FALSE otherwise.
1350 ULONG WINAPI
FBadColumnSet(LPSPropTagArray lpCols
)
1352 ULONG ulRet
= FALSE
, i
;
1354 TRACE("(%p)\n", lpCols
);
1356 if (!lpCols
|| IsBadReadPtr(lpCols
, CbSPropTagArray(lpCols
)))
1360 for (i
= 0; i
< lpCols
->cValues
; i
++)
1362 if ((lpCols
->aulPropTag
[i
] & PROP_TYPE_MASK
) == PT_ERROR
||
1363 FBadPropTag(lpCols
->aulPropTag
[i
]))
1370 TRACE("Returning %s\n", ulRet
? "TRUE" : "FALSE");
1375 /**************************************************************************
1376 * IMAPIProp {MAPI32}
1378 * The default Mapi interface for manipulating object properties.
1381 * This object provides an interface to an objects properties. It is exposed
1382 * by several types of Mapi objects in order to simplify the querying and
1383 * modification of properties.
1388 /* A single property in a property data collection */
1392 ULONG ulAccess
; /* The property value access level */
1393 LPSPropValue value
; /* The property value */
1394 } IPropDataItem
, *LPIPropDataItem
;
1396 /* The main property data collection structure */
1399 IPropDataVtbl
*lpVtbl
;
1400 LONG lRef
; /* Reference count */
1401 ALLOCATEBUFFER
*lpAlloc
; /* Memory allocation routine */
1402 ALLOCATEMORE
*lpMore
; /* Linked memory allocation routine */
1403 FREEBUFFER
*lpFree
; /* Memory free routine */
1404 ULONG ulObjAccess
; /* Object access level */
1405 ULONG ulNumValues
; /* Number of items in values list */
1406 struct list values
; /* List of property values */
1407 CRITICAL_SECTION cs
; /* Lock for thread safety */
1410 /* Internal - Get a property value, assumes lock is held */
1411 static IPropDataItem
*IMAPIPROP_GetValue(IPropDataImpl
*This
, ULONG ulPropTag
)
1413 struct list
*cursor
;
1415 LIST_FOR_EACH(cursor
, &This
->values
)
1417 LPIPropDataItem current
= LIST_ENTRY(cursor
, IPropDataItem
, entry
);
1418 /* Note that propery types don't have to match, just Id's */
1419 if (PROP_ID(current
->value
->ulPropTag
) == PROP_ID(ulPropTag
))
1425 /* Internal - Add a new property value, assumes lock is held */
1426 static IPropDataItem
*IMAPIPROP_AddValue(IPropDataImpl
*This
,
1427 LPSPropValue lpProp
)
1430 LPIPropDataItem lpNew
;
1433 hRet
= This
->lpAlloc(sizeof(IPropDataItem
), &lpMem
);
1435 if (SUCCEEDED(hRet
))
1438 lpNew
->ulAccess
= IPROP_READWRITE
;
1440 /* Allocate the value seperately so we can update it easily */
1442 hRet
= This
->lpAlloc(sizeof(SPropValue
), &lpMem
);
1443 if (SUCCEEDED(hRet
))
1445 lpNew
->value
= lpMem
;
1447 hRet
= PropCopyMore(lpNew
->value
, lpProp
, This
->lpMore
, lpMem
);
1448 if (SUCCEEDED(hRet
))
1450 list_add_tail(&This
->values
, &lpNew
->entry
);
1451 This
->ulNumValues
++;
1454 This
->lpFree(lpNew
->value
);
1456 This
->lpFree(lpNew
);
1461 /* Internal - Lock an IPropData object */
1462 static inline void IMAPIPROP_Lock(IPropDataImpl
*This
)
1464 RtlEnterCriticalSection(&This
->cs
);
1467 /* Internal - Unlock an IPropData object */
1468 static inline void IMAPIPROP_Unlock(IPropDataImpl
*This
)
1470 RtlLeaveCriticalSection(&This
->cs
);
1473 /* This one seems to be missing from mapidefs.h */
1474 #define CbNewSPropProblemArray(c) \
1475 (offsetof(SPropProblemArray,aProblem)+(c)*sizeof(SPropProblem))
1477 /**************************************************************************
1478 * IMAPIProp_QueryInterface {MAPI32}
1480 * Inherited method from the IUnknown Interface.
1481 * See IUnknown_QueryInterface.
1484 * This object exposes the following interfaces:
1485 * - IUnknown() : The default interface for all COM-Objects.
1486 * - IMAPIProp() : The default Mapi interface for manipulating object properties.
1488 static inline HRESULT WINAPI
1489 IMAPIProp_fnQueryInterface(LPMAPIPROP iface
, REFIID riid
, LPVOID
*ppvObj
)
1491 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1493 TRACE("(%p,%s,%p)\n", This
, debugstr_guid(riid
), ppvObj
);
1495 if (!ppvObj
|| !riid
)
1496 return MAPI_E_INVALID_PARAMETER
;
1500 if(IsEqualIID(riid
, &IID_IUnknown
) ||
1501 IsEqualIID(riid
, &IID_IMAPIProp
) ||
1502 IsEqualIID(riid
, &IID_IMAPIPropData
))
1505 IPropData_AddRef(iface
);
1506 TRACE("returning %p\n", *ppvObj
);
1510 TRACE("returning E_NOINTERFACE\n");
1511 return MAPI_E_INTERFACE_NOT_SUPPORTED
;
1514 /**************************************************************************
1515 * IMAPIProp_AddRef {MAPI32}
1517 * Inherited method from the IUnknown Interface.
1518 * See IUnknown_AddRef.
1520 static inline ULONG WINAPI
IMAPIProp_fnAddRef(LPMAPIPROP iface
)
1522 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1524 TRACE("(%p)->(count=%ld)\n", This
, This
->lRef
);
1526 return InterlockedIncrement(&This
->lRef
);
1529 /**************************************************************************
1530 * IMAPIProp_Release {MAPI32}
1532 * Inherited method from the IUnknown Interface.
1533 * See IUnknown_Release.
1535 static inline ULONG WINAPI
IMAPIProp_fnRelease(LPMAPIPROP iface
)
1537 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1539 TRACE("(%p)->()\n", This
);
1541 if (!InterlockedDecrement(&This
->lRef
))
1543 TRACE("Destroying IPropData (%p)\n",This
);
1545 /* Note: No need to lock, since no other thread is referencing iface */
1546 while (!list_empty(&This
->values
))
1548 struct list
*head
= list_head(&This
->values
);
1549 LPIPropDataItem current
= LIST_ENTRY(head
, IPropDataItem
, entry
);
1551 This
->lpFree(current
->value
);
1552 This
->lpFree(current
);
1554 RtlDeleteCriticalSection(&This
->cs
);
1558 return (ULONG
)This
->lRef
;
1561 /**************************************************************************
1562 * IMAPIProp_GetLastError {MAPI32}
1564 * Get information about the last error that ocurred in an IMAPIProp object.
1567 * iface [I] IMAPIProp object that experienced the error
1568 * hRes [I] Result of the call that returned an error
1569 * ulFlags [I] 0=return Ascii strings, MAPI_UNICODE=return Unicode strings
1570 * lppError [O] Destination for detailed error information
1573 * Success: S_OK. *lppError contains details about the last error.
1574 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid,
1575 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
1578 * - If this function succeeds, the returned information in *lppError must be
1579 * freed using MAPIFreeBuffer() once the caller is finished with it.
1580 * - It is possible for this function to suceed and set *lppError to NULL,
1581 * if there is no further information to report about hRes.
1583 static inline HRESULT WINAPI
1584 IMAPIProp_fnGetLastError(LPMAPIPROP iface
, HRESULT hRes
,
1585 ULONG ulFlags
, LPMAPIERROR
*lppError
)
1587 TRACE("(%p,0x%08lX,0x%08lX,%p)\n", iface
, hRes
, ulFlags
, lppError
);
1589 if (!lppError
|| SUCCEEDED(hRes
) || (ulFlags
& ~MAPI_UNICODE
))
1590 return MAPI_E_INVALID_PARAMETER
;
1596 /**************************************************************************
1597 * IMAPIProp_SaveChanges {MAPI32}
1599 * Update any changes made to a tansactional IMAPIProp object.
1602 * iface [I] IMAPIProp object to update
1603 * ulFlags [I] Flags controlling the update.
1606 * Success: S_OK. Any outstanding changes are committed to the object.
1607 * Failure: An HRESULT error code describing the error.
1609 static inline HRESULT WINAPI
1610 IMAPIProp_fnSaveChanges(LPMAPIPROP iface
, ULONG ulFlags
)
1612 TRACE("(%p,0x%08lX)\n", iface
, ulFlags
);
1614 /* Since this object is not transacted we do not need to implement this */
1615 /* FIXME: Should we set the access levels to clean? */
1619 /**************************************************************************
1620 * IMAPIProp_GetProps {MAPI32}
1622 * Get property values from an IMAPIProp object.
1625 * iface [I] IMAPIProp object to get the property values from
1626 * lpTags [I] Property tage of property values to be retrieved
1627 * ulFlags [I] Return 0=Ascii MAPI_UNICODE=Unicode strings for
1629 * lpCount [O] Destination for number of properties returned
1630 * lppProps [O] Destination for returned property values
1633 * Success: S_OK. *lppProps and *lpCount are updated.
1634 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1635 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
1636 * MAPI_W_ERRORS_RETURNED if not all properties were retrieved
1639 * - If MAPI_W_ERRORS_RETURNED is returned, any properties that could not be
1640 * retrieved from iface are present in lppProps with thier type
1641 * changed to PT_ERROR and Id unchanged.
1643 static inline HRESULT WINAPI
1644 IMAPIProp_fnGetProps(LPMAPIPROP iface
, LPSPropTagArray lpTags
,
1645 ULONG ulFlags
, ULONG
*lpCount
, LPSPropValue
*lppProps
)
1648 HRESULT hRet
= S_OK
;
1649 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1651 TRACE("(%p,%p,0x%08lx,%p,%p) stub\n", iface
, lpTags
, ulFlags
,
1654 if (!iface
|| ulFlags
& ~MAPI_UNICODE
|| !lpTags
|| *lpCount
|| !lppProps
)
1655 return MAPI_E_INVALID_PARAMETER
;
1657 FIXME("semi-stub, flags not supported\n");
1659 *lpCount
= lpTags
->cValues
;
1664 hRet
= MAPIAllocateBuffer(*lpCount
* sizeof(SPropValue
), (LPVOID
*)lppProps
);
1668 IMAPIPROP_Lock(This
);
1670 for (i
= 0; i
< lpTags
->cValues
; i
++)
1672 HRESULT hRetTmp
= E_INVALIDARG
;
1673 LPIPropDataItem item
;
1675 item
= IMAPIPROP_GetValue(This
, lpTags
->aulPropTag
[i
]);
1678 hRetTmp
= PropCopyMore(&(*lppProps
)[i
], item
->value
,
1679 This
->lpMore
, *lppProps
);
1680 if (FAILED(hRetTmp
))
1682 hRet
= MAPI_W_ERRORS_RETURNED
;
1683 (*lppProps
)[i
].ulPropTag
=
1684 CHANGE_PROP_TYPE(lpTags
->aulPropTag
[i
], PT_ERROR
);
1688 IMAPIPROP_Unlock(This
);
1693 /**************************************************************************
1694 * MAPIProp_GetPropList {MAPI32}
1696 * Get the list of property tags for all values in an IMAPIProp object.
1699 * iface [I] IMAPIProp object to get the property tag list from
1700 * ulFlags [I] Return 0=Ascii MAPI_UNICODE=Unicode strings for
1702 * lppTags [O] Destination for the retrieved peoperty tag list
1705 * Success: S_OK. *lppTags contains the tags for all available properties.
1706 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1707 * MAPI_E_BAD_CHARWIDTH, if Ascii or Unicode strings are requested
1708 * and that type of string is not supported.
1710 static inline HRESULT WINAPI
1711 IMAPIProp_fnGetPropList(LPMAPIPROP iface
, ULONG ulFlags
,
1712 LPSPropTagArray
*lppTags
)
1714 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1718 TRACE("(%p,0x%08lx,%p) stub\n", iface
, ulFlags
, lppTags
);
1720 if (!iface
|| ulFlags
& ~MAPI_UNICODE
|| !lppTags
)
1721 return MAPI_E_INVALID_PARAMETER
;
1723 FIXME("semi-stub, flags not supported\n");
1727 IMAPIPROP_Lock(This
);
1729 hRet
= MAPIAllocateBuffer(CbNewSPropTagArray(This
->ulNumValues
),
1731 if (SUCCEEDED(hRet
))
1733 struct list
*cursor
;
1736 LIST_FOR_EACH(cursor
, &This
->values
)
1738 LPIPropDataItem current
= LIST_ENTRY(cursor
, IPropDataItem
, entry
);
1739 (*lppTags
)->aulPropTag
[i
] = current
->value
->ulPropTag
;
1742 (*lppTags
)->cValues
= This
->ulNumValues
;
1745 IMAPIPROP_Unlock(This
);
1749 /**************************************************************************
1750 * IMAPIProp_OpenProperty {MAPI32}
1752 * Not documented at this time.
1755 * An HRESULT success/failure code.
1757 static inline HRESULT WINAPI
1758 IMAPIProp_fnOpenProperty(LPMAPIPROP iface
, ULONG ulPropTag
, LPCIID iid
,
1759 ULONG ulOpts
, ULONG ulFlags
, LPUNKNOWN
*lpUnk
)
1761 FIXME("(%p,%lu,%s,%lu,0x%08lx,%p) stub\n", iface
, ulPropTag
,
1762 debugstr_guid(iid
), ulOpts
, ulFlags
, lpUnk
);
1763 return MAPI_E_NO_SUPPORT
;
1767 /**************************************************************************
1768 * IMAPIProp_SetProps {MAPI32}
1770 * Add or edit the property values in an IMAPIProp object.
1773 * iface [I] IMAPIProp object to get the property tag list from
1774 * ulValues [I] Number of properties in lpProps
1775 * lpProps [I] Property values to set
1776 * lppProbs [O] Optional destination for any problems that occurred
1779 * Success: S_OK. The properties in lpProps are added to iface if they don't
1780 * exist, or changed to the values in lpProps if they do
1781 * Failure: An HRESULT error code describing the error
1783 static inline HRESULT WINAPI
1784 IMAPIProp_fnSetProps(LPMAPIPROP iface
, ULONG ulValues
,
1785 LPSPropValue lpProps
, LPSPropProblemArray
*lppProbs
)
1787 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1788 HRESULT hRet
= S_OK
;
1791 TRACE("(%p,%lu,%p,%p)\n", iface
, ulValues
, lpProps
, lppProbs
);
1793 if (!iface
|| !lpProps
)
1794 return MAPI_E_INVALID_PARAMETER
;
1796 for (i
= 0; i
< ulValues
; i
++)
1798 if (FBadProp(&lpProps
[i
]) ||
1799 PROP_TYPE(lpProps
[i
].ulPropTag
) == PT_OBJECT
||
1800 PROP_TYPE(lpProps
[i
].ulPropTag
) == PT_NULL
)
1801 return MAPI_E_INVALID_PARAMETER
;
1804 IMAPIPROP_Lock(This
);
1806 /* FIXME: Under what circumstances is lpProbs created? */
1807 for (i
= 0; i
< ulValues
; i
++)
1809 LPIPropDataItem item
= IMAPIPROP_GetValue(This
, lpProps
[i
].ulPropTag
);
1814 LPVOID lpMem
= NULL
;
1816 /* Found, so update the existing value */
1817 if (item
->value
->ulPropTag
!= lpProps
[i
].ulPropTag
)
1818 FIXME("semi-stub, overwriting type (not coercing)\n");
1820 hRetTmp
= This
->lpAlloc(sizeof(SPropValue
), &lpMem
);
1821 if (SUCCEEDED(hRetTmp
))
1823 hRetTmp
= PropCopyMore(lpMem
, &lpProps
[i
], This
->lpMore
, lpMem
);
1824 if (SUCCEEDED(hRetTmp
))
1826 This
->lpFree(item
->value
);
1827 item
->value
= lpMem
;
1830 This
->lpFree(lpMem
);
1837 if (!(item
= IMAPIPROP_AddValue(This
, &lpProps
[i
])))
1838 hRet
= MAPI_E_NOT_ENOUGH_MEMORY
;
1842 IMAPIPROP_Unlock(This
);
1846 /**************************************************************************
1847 * IMAPIProp_DeleteProps {MAPI32}
1849 * Delete one or more property values from a IMAPIProp objects.
1852 * iface [I] IMAPIProp object to remove property values from.
1853 * lpTags [I] Collection of property Id's to remove from iface.
1854 * lppProbs [O] Destination for problems encountered, if any.
1857 * Success: S_OK. Any properties in iface matching property Id's in lpTags have
1858 * been deleted. If lppProbs is non-NULL it contains details of any
1859 * errors that occurred.
1860 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1861 * E_ACCESSDENIED, if this object was created using CreateIProp() and
1862 * a subsequent call to IPropData_SetObjAcess() was made specifying
1863 * IPROP_READONLY as the access type.
1866 * - lppProbs will not be populated for cases where a property Id is present
1867 * in lpTags but not in iface.
1868 * - lppProbs should be deleted with MAPIFreeBuffer() if returned.
1870 static inline HRESULT WINAPI
1871 IMAPIProp_fnDeleteProps(LPMAPIPROP iface
, LPSPropTagArray lpTags
,
1872 LPSPropProblemArray
*lppProbs
)
1874 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
1875 ULONG i
, numProbs
= 0;
1876 HRESULT hRet
= S_OK
;
1878 TRACE("(%p,%p,%p)\n", iface
, lpTags
, lppProbs
);
1880 if (!iface
|| !lpTags
)
1881 return MAPI_E_INVALID_PARAMETER
;
1886 for (i
= 0; i
< lpTags
->cValues
; i
++)
1888 if (FBadPropTag(lpTags
->aulPropTag
[i
]) ||
1889 PROP_TYPE(lpTags
->aulPropTag
[i
]) == PT_OBJECT
||
1890 PROP_TYPE(lpTags
->aulPropTag
[i
]) == PT_NULL
)
1891 return MAPI_E_INVALID_PARAMETER
;
1894 IMAPIPROP_Lock(This
);
1896 if (This
->ulObjAccess
!= IPROP_READWRITE
)
1898 IMAPIPROP_Unlock(This
);
1899 return E_ACCESSDENIED
;
1902 for (i
= 0; i
< lpTags
->cValues
; i
++)
1904 LPIPropDataItem item
= IMAPIPROP_GetValue(This
, lpTags
->aulPropTag
[i
]);
1908 if (item
->ulAccess
& IPROP_READWRITE
)
1910 /* Everything hunky-dory, remove the item */
1911 list_remove(&item
->entry
);
1912 This
->lpFree(item
->value
); /* Also frees value pointers */
1914 This
->ulNumValues
--;
1918 /* Can't write the value. Create/populate problems array */
1921 /* Create problems array */
1922 ULONG ulSize
= CbNewSPropProblemArray(lpTags
->cValues
- i
);
1923 HRESULT hRetTmp
= MAPIAllocateBuffer(ulSize
, (LPVOID
*)lppProbs
);
1924 if (FAILED(hRetTmp
))
1929 LPSPropProblem lpProb
= &(*lppProbs
)->aProblem
[numProbs
];
1930 lpProb
->ulIndex
= i
;
1931 lpProb
->ulPropTag
= lpTags
->aulPropTag
[i
];
1932 lpProb
->scode
= E_ACCESSDENIED
;
1938 if (lppProbs
&& *lppProbs
)
1939 (*lppProbs
)->cProblem
= numProbs
;
1941 IMAPIPROP_Unlock(This
);
1946 /**************************************************************************
1947 * IMAPIProp_CopyTo {MAPI32}
1949 * Not documented at this time.
1952 * An HRESULT success/failure code.
1954 static inline HRESULT WINAPI
1955 IMAPIProp_fnCopyTo(LPMAPIPROP iface
, ULONG niids
, LPCIID lpiidExcl
,
1956 LPSPropTagArray lpPropsExcl
, ULONG ulParam
,
1957 LPMAPIPROGRESS lpIProgress
, LPCIID lpIfaceIid
, LPVOID lpDstObj
,
1958 ULONG ulFlags
, LPSPropProblemArray
*lppProbs
)
1960 FIXME("(%p,%lu,%p,%p,%lx,%p,%s,%p,0x%08lX,%p) stub\n", iface
, niids
,
1961 lpiidExcl
, lpPropsExcl
, ulParam
, lpIProgress
,
1962 debugstr_guid(lpIfaceIid
), lpDstObj
, ulFlags
, lppProbs
);
1963 return MAPI_E_NO_SUPPORT
;
1966 /**************************************************************************
1967 * IMAPIProp_CopyProps {MAPI32}
1969 * Not documented at this time.
1972 * An HRESULT success/failure code.
1974 static inline HRESULT WINAPI
1975 IMAPIProp_fnCopyProps(LPMAPIPROP iface
, LPSPropTagArray lpInclProps
,
1976 ULONG ulParam
, LPMAPIPROGRESS lpIProgress
, LPCIID lpIface
,
1977 LPVOID lpDstObj
, ULONG ulFlags
,
1978 LPSPropProblemArray
*lppProbs
)
1980 FIXME("(%p,%p,%lx,%p,%s,%p,0x%08lX,%p) stub\n", iface
, lpInclProps
,
1981 ulParam
, lpIProgress
, debugstr_guid(lpIface
), lpDstObj
, ulFlags
,
1983 return MAPI_E_NO_SUPPORT
;
1986 /**************************************************************************
1987 * IMAPIProp_GetNamesFromIDs {MAPI32}
1989 * Get the names of properties from thier identifiers.
1992 * iface [I] IMAPIProp object to operate on
1993 * lppPropTags [I/O] Property identifiers to get the names for, or NULL to
1995 * iid [I] Property set identifier, or NULL
1996 * ulFlags [I] MAPI_NO_IDS=Don't return numeric named properties,
1997 * or MAPI_NO_STRINGS=Don't return strings
1998 * lpCount [O] Destination for number of properties returned
1999 * lpppNames [O] Destination for returned names
2002 * Success: S_OK. *lppPropTags and lpppNames contain the returned
2004 * Failure: MAPI_E_NO_SUPPORT, if the object does not support named properties,
2005 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
2006 * MAPI_W_ERRORS_RETURNED if not all properties were retrieved
2009 static inline HRESULT WINAPI
2010 IMAPIProp_fnGetNamesFromIDs(LPMAPIPROP iface
, LPSPropTagArray
*lppPropTags
,
2011 LPGUID iid
, ULONG ulFlags
, ULONG
*lpCount
,
2012 LPMAPINAMEID
**lpppNames
)
2014 FIXME("(%p,%p,%s,0x%08lX,%p,%p) stub\n", iface
, lppPropTags
,
2015 debugstr_guid(iid
), ulFlags
, lpCount
, lpppNames
);
2016 return MAPI_E_NO_SUPPORT
;
2019 /**************************************************************************
2020 * IMAPIProp_GetIDsFromNames {MAPI32}
2022 * Get property identifiers associated with one or more named properties.
2025 * iface [I] IMAPIProp object to operate on
2026 * ulNames [I] Number of names in lppNames
2027 * lppNames [I] Names to query or create, or NULL to query all names
2028 * ulFlags [I] Pass MAPI_CREATE to create new named properties
2029 * lppPropTags [O] Destination for queried or created property identifiers
2032 * Success: S_OK. *lppPropTags contains the property tags created or requested.
2033 * Failure: MAPI_E_NO_SUPPORT, if the object does not support named properties,
2034 * MAPI_E_TOO_BIG, if the object cannot process the number of
2035 * properties involved.
2036 * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
2037 * MAPI_W_ERRORS_RETURNED if not all properties were retrieved
2040 static inline HRESULT WINAPI
2041 IMAPIProp_fnGetIDsFromNames(LPMAPIPROP iface
, ULONG ulNames
,
2042 LPMAPINAMEID
*lppNames
, ULONG ulFlags
,
2043 LPSPropTagArray
*lppPropTags
)
2045 FIXME("(%p,%ld,%p,0x%08lX,%p) stub\n",
2046 iface
, ulNames
, lppNames
, ulFlags
, lppPropTags
);
2047 return MAPI_E_NO_SUPPORT
;
2050 /**************************************************************************
2051 * IPropData {MAPI32}
2053 * A default Mapi interface to provide manipulation of object properties.
2056 * This object provides a default interface suitable in some cases as an
2057 * implementation of the IMAPIProp interface (which has no default
2058 * implementation). In addition to the IMAPIProp() methods inherited, this
2059 * interface allows read/write control over access to the object and its
2060 * individual properties.
2062 * To obtain the default implementation of this interface from Mapi, call
2068 /**************************************************************************
2069 * IPropData_QueryInterface {MAPI32}
2071 * Inherited method from the IMAPIProp Interface.
2072 * See IMAPIProp_QueryInterface.
2074 static HRESULT WINAPI
2075 IPropData_fnQueryInterface(LPPROPDATA iface
, REFIID riid
, LPVOID
*ppvObj
)
2077 return IMAPIProp_fnQueryInterface((LPMAPIPROP
)iface
, riid
, ppvObj
);
2080 /**************************************************************************
2081 * IPropData_AddRef {MAPI32}
2083 * Inherited method from the IMAPIProp Interface.
2084 * See IMAPIProp_AddRef.
2087 IPropData_fnAddRef(LPPROPDATA iface
)
2089 return IMAPIProp_fnAddRef((LPMAPIPROP
)iface
);
2092 /**************************************************************************
2093 * IPropData_Release {MAPI32}
2095 * Inherited method from the IMAPIProp Interface.
2096 * See IMAPIProp_Release.
2099 IPropData_fnRelease(LPPROPDATA iface
)
2101 return IMAPIProp_fnRelease((LPMAPIPROP
)iface
);
2104 /**************************************************************************
2105 * IPropData_GetLastError {MAPI32}
2107 * Inherited method from the IMAPIProp Interface.
2108 * See IMAPIProp_GetLastError.
2110 static HRESULT WINAPI
2111 IPropData_fnGetLastError(LPPROPDATA iface
, HRESULT hRes
, ULONG ulFlags
,
2112 LPMAPIERROR
*lppError
)
2114 return IMAPIProp_fnGetLastError((LPMAPIPROP
)iface
, hRes
, ulFlags
, lppError
);
2117 /**************************************************************************
2118 * IPropData_SaveChanges {MAPI32}
2120 * Inherited method from the IMAPIProp Interface.
2121 * See IMAPIProp_SaveChanges.
2123 static HRESULT WINAPI
2124 IPropData_fnSaveChanges(LPPROPDATA iface
, ULONG ulFlags
)
2126 return IMAPIProp_fnSaveChanges((LPMAPIPROP
)iface
, ulFlags
);
2129 /**************************************************************************
2130 * IPropData_GetProps {MAPI32}
2132 * Inherited method from the IMAPIProp Interface.
2133 * See IMAPIProp_GetProps.
2135 static HRESULT WINAPI
2136 IPropData_fnGetProps(LPPROPDATA iface
, LPSPropTagArray lpPropTags
,
2137 ULONG ulFlags
, ULONG
*lpCount
, LPSPropValue
*lppProps
)
2139 return IMAPIProp_fnGetProps((LPMAPIPROP
)iface
, lpPropTags
, ulFlags
,
2143 /**************************************************************************
2144 * IPropData_GetPropList {MAPI32}
2146 * Inherited method from the IMAPIProp Interface.
2147 * See IMAPIProp_GetPropList.
2149 static HRESULT WINAPI
2150 IPropData_fnGetPropList(LPPROPDATA iface
, ULONG ulFlags
,
2151 LPSPropTagArray
*lppPropTags
)
2153 return IMAPIProp_fnGetPropList((LPMAPIPROP
)iface
, ulFlags
, lppPropTags
);
2156 /**************************************************************************
2157 * IPropData_OpenProperty {MAPI32}
2159 * Inherited method from the IMAPIProp Interface.
2160 * See IMAPIProp_OpenProperty.
2162 static HRESULT WINAPI
2163 IPropData_fnOpenProperty(LPPROPDATA iface
, ULONG ulPropTag
, LPCIID iid
,
2164 ULONG ulOpts
, ULONG ulFlags
, LPUNKNOWN
*lpUnk
)
2166 return IMAPIProp_fnOpenProperty((LPMAPIPROP
)iface
, ulPropTag
, iid
,
2167 ulOpts
, ulFlags
, lpUnk
);
2170 /**************************************************************************
2171 * IPropData_SetProps {MAPI32}
2173 * Inherited method from the IMAPIProp Interface.
2174 * See IMAPIProp_SetProps.
2176 static HRESULT WINAPI
2177 IPropData_fnSetProps(LPPROPDATA iface
, ULONG cValues
, LPSPropValue lpProps
,
2178 LPSPropProblemArray
*lppProbs
)
2180 return IMAPIProp_fnSetProps((LPMAPIPROP
)iface
, cValues
, lpProps
, lppProbs
);
2183 /**************************************************************************
2184 * IPropData_DeleteProps {MAPI32}
2186 * Inherited method from the IMAPIProp Interface.
2187 * See IMAPIProp_DeleteProps.
2189 static HRESULT WINAPI
2190 IPropData_fnDeleteProps(LPPROPDATA iface
, LPSPropTagArray lpPropTags
,
2191 LPSPropProblemArray
*lppProbs
)
2193 return IMAPIProp_fnDeleteProps((LPMAPIPROP
)iface
, lpPropTags
, lppProbs
);
2196 /**************************************************************************
2197 * IPropData_CopyTo {MAPI32}
2199 * Inherited method from the IMAPIProp Interface.
2200 * See IMAPIProp_CopyTo.
2202 static HRESULT WINAPI
2203 IPropData_fnCopyTo(LPPROPDATA iface
, ULONG ciidExclude
, LPCIID lpIid
,
2204 LPSPropTagArray lpProps
, ULONG ulParam
,
2205 LPMAPIPROGRESS lpProgress
, LPCIID lpIface
, LPVOID lpDst
,
2206 ULONG ulFlags
, LPSPropProblemArray
*lppProbs
)
2208 return IMAPIProp_fnCopyTo((LPMAPIPROP
)iface
, ciidExclude
, lpIid
, lpProps
,
2209 ulParam
, lpProgress
, lpIface
, lpDst
,
2213 /**************************************************************************
2214 * IPropData_CopyProps {MAPI32}
2216 * Inherited method from the IMAPIProp Interface.
2217 * See IMAPIProp_CopyProps.
2219 static HRESULT WINAPI
2220 IPropData_fnCopyProps(LPPROPDATA iface
, LPSPropTagArray lpProps
,
2221 ULONG ulParam
, LPMAPIPROGRESS lpProgress
, LPCIID lpIface
,
2222 LPVOID lpDst
, ULONG ulFlags
, LPSPropProblemArray
*lppProbs
)
2224 return IMAPIProp_fnCopyProps((LPMAPIPROP
)iface
, lpProps
, ulParam
,
2225 lpProgress
, lpIface
, lpDst
, ulFlags
, lppProbs
);
2228 /**************************************************************************
2229 * IPropData_GetNamesFromIDs {MAPI32}
2231 * Inherited method from the IMAPIProp Interface.
2232 * See IMAPIProp_GetNamesFromIDs.
2234 static HRESULT WINAPI
2235 IPropData_fnGetNamesFromIDs(LPPROPDATA iface
, LPSPropTagArray
*lppPropTags
,
2236 LPGUID iid
, ULONG ulFlags
, ULONG
*lpCount
,
2237 LPMAPINAMEID
**lpppNames
)
2239 return IMAPIProp_fnGetNamesFromIDs((LPMAPIPROP
)iface
, lppPropTags
, iid
,
2240 ulFlags
, lpCount
, lpppNames
);
2243 /**************************************************************************
2244 * IPropData_GetIDsFromNames {MAPI32}
2246 * Inherited method from the IMAPIProp Interface.
2247 * See IMAPIProp_GetIDsFromNames.
2249 static HRESULT WINAPI
2250 IPropData_fnGetIDsFromNames(LPPROPDATA iface
, ULONG ulNames
,
2251 LPMAPINAMEID
*lppNames
, ULONG ulFlags
,
2252 LPSPropTagArray
*lppPropTags
)
2254 return IMAPIProp_fnGetIDsFromNames((LPMAPIPROP
)iface
, ulNames
, lppNames
,
2255 ulFlags
, lppPropTags
);
2258 /**************************************************************************
2259 * IPropData_HrSetObjAccess {MAPI32}
2261 * Set the access level of an IPropData object.
2264 * iface [I] IPropData object to set the access on
2265 * ulAccess [I] Either IPROP_READONLY or IPROP_READWRITE for read or
2266 * read/write access respectively.
2269 * Success: S_OK. The objects access level is changed.
2270 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
2272 static HRESULT WINAPI
2273 IPropData_fnHrSetObjAccess(LPPROPDATA iface
, ULONG ulAccess
)
2275 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
2277 TRACE("(%p,%lx)\n", iface
, ulAccess
);
2279 if (!iface
|| ulAccess
< IPROP_READONLY
|| ulAccess
> IPROP_READWRITE
)
2280 return MAPI_E_INVALID_PARAMETER
;
2282 IMAPIPROP_Lock(This
);
2284 This
->ulObjAccess
= ulAccess
;
2286 IMAPIPROP_Unlock(This
);
2290 /* Internal - determine if an access value is bad */
2291 static inline BOOL
PROP_IsBadAccess(ULONG ulAccess
)
2295 case IPROP_READONLY
|IPROP_CLEAN
:
2296 case IPROP_READONLY
|IPROP_DIRTY
:
2297 case IPROP_READWRITE
|IPROP_CLEAN
:
2298 case IPROP_READWRITE
|IPROP_DIRTY
:
2304 /**************************************************************************
2305 * IPropData_HrSetPropAccess {MAPI32}
2307 * Set the access levels for a group of property values in an IPropData object.
2310 * iface [I] IPropData object to set access levels in.
2311 * lpTags [I] List of property Id's to set access for.
2312 * lpAccess [O] Access level for each property in lpTags.
2315 * Success: S_OK. The access level of each property value in lpTags that is
2316 * present in iface is changed.
2317 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
2320 * - Each access level in lpAccess must contain at least one of IPROP_READONLY
2321 * or IPROP_READWRITE, but not both, and also IPROP_CLEAN or IPROP_DIRTY,
2322 * but not both. No other bits should be set.
2323 * - If a property Id in lpTags is not present in iface, it is ignored.
2325 static HRESULT WINAPI
2326 IPropData_fnHrSetPropAccess(LPPROPDATA iface
, LPSPropTagArray lpTags
,
2329 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
2333 TRACE("(%p,%p,%p)\n", iface
, lpTags
, lpAccess
);
2335 if (!iface
|| !lpTags
|| !lpAccess
)
2336 return MAPI_E_INVALID_PARAMETER
;
2338 for (i
= 0; i
< lpTags
->cValues
; i
++)
2340 if (FBadPropTag(lpTags
->aulPropTag
[i
]) || PROP_IsBadAccess(lpAccess
[i
]))
2341 return MAPI_E_INVALID_PARAMETER
;
2344 IMAPIPROP_Lock(This
);
2346 for (i
= 0; i
< lpTags
->cValues
; i
++)
2348 LPIPropDataItem item
= IMAPIPROP_GetValue(This
, lpTags
->aulPropTag
[i
]);
2351 item
->ulAccess
= lpAccess
[i
];
2354 IMAPIPROP_Unlock(This
);
2358 /**************************************************************************
2359 * IPropData_HrGetPropAccess {MAPI32}
2361 * Get the access levels for a group of property values in an IPropData object.
2364 * iface [I] IPropData object to get access levels from.
2365 * lppTags [O] Destination for the list of property Id's in iface.
2366 * lppAccess [O] Destination for access level for each property in lppTags.
2369 * Success: S_OK. lppTags and lppAccess contain the property Id's and the
2370 * Access level of each property value in iface.
2371 * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid, or
2372 * MAPI_E_NOT_ENOUGH_MEMORY if memory allocation fails.
2375 * - *lppTags and *lppAccess should be freed with MAPIFreeBuffer() by the caller.
2377 static HRESULT WINAPI
2378 IPropData_fnHrGetPropAccess(LPPROPDATA iface
, LPSPropTagArray
*lppTags
,
2381 IPropDataImpl
*This
= (IPropDataImpl
*)iface
;
2386 TRACE("(%p,%p,%p) stub\n", iface
, lppTags
, lppAccess
);
2388 if (!iface
|| !lppTags
|| !lppAccess
)
2389 return MAPI_E_INVALID_PARAMETER
;
2394 IMAPIPROP_Lock(This
);
2396 hRet
= This
->lpAlloc(CbNewSPropTagArray(This
->ulNumValues
), &lpMem
);
2397 if (SUCCEEDED(hRet
))
2401 hRet
= This
->lpAlloc(This
->ulNumValues
* sizeof(ULONG
), &lpMem
);
2402 if (SUCCEEDED(hRet
))
2404 struct list
*cursor
;
2407 (*lppTags
)->cValues
= This
->ulNumValues
;
2410 LIST_FOR_EACH(cursor
, &This
->values
)
2412 LPIPropDataItem item
= LIST_ENTRY(cursor
, IPropDataItem
, entry
);
2413 (*lppTags
)->aulPropTag
[i
] = item
->value
->ulPropTag
;
2414 (*lppAccess
)[i
] = item
->ulAccess
;
2417 IMAPIPROP_Unlock(This
);
2420 This
->lpFree(*lppTags
);
2423 IMAPIPROP_Unlock(This
);
2424 return MAPI_E_NOT_ENOUGH_MEMORY
;
2427 /**************************************************************************
2428 * IPropData_HrAddObjProps {MAPI32}
2430 * Not documented at this time.
2433 * An HRESULT success/failure code.
2435 static HRESULT WINAPI
2436 IPropData_fnHrAddObjProps(LPPROPDATA iface
, LPSPropTagArray lpTags
,
2437 LPSPropProblemArray
*lppProbs
)
2442 LPSPropValue lpValues
;
2445 FIXME("(%p,%p,%p) stub\n", iface
, lpTags
, lppProbs
);
2447 if (!iface
|| !lpTags
)
2448 return MAPI_E_INVALID_PARAMETER
;
2450 /* FIXME: Below is the obvious implementation, adding all the properties
2451 * in lpTags to the object. However, it doesn't appear that this
2452 * is what this function does.
2456 if (!lpTags
->cValues
)
2459 lpValues
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2460 lpTags
->cValues
* sizeof(SPropValue
));
2462 return MAPI_E_NOT_ENOUGH_MEMORY
;
2464 for (i
= 0; i
< lpTags
->cValues
; i
++)
2465 lpValues
[i
].ulPropTag
= lpTags
->aulPropTag
[i
];
2467 hRet
= IPropData_SetProps(iface
, lpTags
->cValues
, lpValues
, lppProbs
);
2468 HeapFree(GetProcessHeap(), 0, lpValues
);
2473 static struct IPropDataVtbl IPropDataImpl_vtbl
=
2475 IPropData_fnQueryInterface
,
2477 IPropData_fnRelease
,
2478 IPropData_fnGetLastError
,
2479 IPropData_fnSaveChanges
,
2480 IPropData_fnGetProps
,
2481 IPropData_fnGetPropList
,
2482 IPropData_fnOpenProperty
,
2483 IPropData_fnSetProps
,
2484 IPropData_fnDeleteProps
,
2486 IPropData_fnCopyProps
,
2487 IPropData_fnGetNamesFromIDs
,
2488 IPropData_fnGetIDsFromNames
,
2489 IPropData_fnHrSetObjAccess
,
2490 IPropData_fnHrSetPropAccess
,
2491 IPropData_fnHrGetPropAccess
,
2492 IPropData_fnHrAddObjProps
2495 /*************************************************************************
2496 * CreateIProp@24 (MAPI32.60)
2498 * Create an IPropData object.
2501 * iid [I] GUID of the object to create. Use &IID_IMAPIPropData or NULL
2502 * lpAlloc [I] Memory allocation function. Use MAPIAllocateBuffer()
2503 * lpMore [I] Linked memory allocation function. Use MAPIAllocateMore()
2504 * lpFree [I] Memory free function. Use MAPIFreeBuffer()
2505 * lpReserved [I] Reserved, set to NULL
2506 * lppPropData [O] Destination for created IPropData object
2509 * Success: S_OK. *lppPropData contains the newly created object.
2510 * Failure: MAPI_E_INTERFACE_NOT_SUPPORTED, if iid is non-NULL and not supported,
2511 * MAPI_E_INVALID_PARAMETER, if any parameter is invalid
2513 SCODE WINAPI
CreateIProp(LPCIID iid
, ALLOCATEBUFFER
*lpAlloc
,
2514 ALLOCATEMORE
*lpMore
, FREEBUFFER
*lpFree
,
2515 LPVOID lpReserved
, LPPROPDATA
*lppPropData
)
2517 IPropDataImpl
*lpPropData
;
2520 TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_guid(iid
), lpAlloc
, lpMore
, lpFree
,
2521 lpReserved
, lppPropData
);
2524 *lppPropData
= NULL
;
2526 if (iid
&& !IsEqualGUID(iid
, &IID_IMAPIPropData
))
2527 return MAPI_E_INTERFACE_NOT_SUPPORTED
;
2529 if (!lpAlloc
|| !lpMore
|| !lpFree
|| lpReserved
|| !lppPropData
)
2530 return MAPI_E_INVALID_PARAMETER
;
2532 scode
= lpAlloc(sizeof(IPropDataImpl
), (LPVOID
*)&lpPropData
);
2534 if (SUCCEEDED(scode
))
2536 lpPropData
->lpVtbl
= &IPropDataImpl_vtbl
;
2537 lpPropData
->lRef
= 1;
2538 lpPropData
->lpAlloc
= lpAlloc
;
2539 lpPropData
->lpMore
= lpMore
;
2540 lpPropData
->lpFree
= lpFree
;
2541 lpPropData
->ulObjAccess
= IPROP_READWRITE
;
2542 lpPropData
->ulNumValues
= 0;
2543 list_init(&lpPropData
->values
);
2544 RtlInitializeCriticalSection(&lpPropData
->cs
);
2545 *lppPropData
= (LPPROPDATA
)lpPropData
;