wininet: Trace more parameters to HTTP_GetCustomHeaderIndex.
[wine] / dlls / mapi32 / prop.c
1 /*
2  * Property functions
3  *
4  * Copyright 2004 Jon Griffiths
5  *
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.
10  *
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.
15  *
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winreg.h"
27 #include "winerror.h"
28 #include "winternl.h"
29 #include "objbase.h"
30 #include "shlwapi.h"
31 #include "wine/list.h"
32 #include "wine/debug.h"
33 #include "wine/unicode.h"
34 #include "mapival.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mapi);
37
38 BOOL WINAPI FBadRglpszA(LPSTR*,ULONG);
39
40 /* Internal: Check if a property value array is invalid */
41 static inline ULONG PROP_BadArray(LPSPropValue lpProp, size_t elemSize)
42 {
43     return IsBadReadPtr(lpProp->Value.MVi.lpi, lpProp->Value.MVi.cValues * elemSize);
44 }
45
46 /*************************************************************************
47  * PropCopyMore@16 (MAPI32.76)
48  *
49  * Copy a property value.
50  *
51  * PARAMS
52  *  lpDest [O] Destination for the copied value
53  *  lpSrc  [I] Property value to copy to lpDest
54  *  lpMore [I] Linked memory allocation function (pass MAPIAllocateMore())
55  *  lpOrig [I] Original allocation to which memory will be linked
56  *
57  * RETURNS
58  *  Success: S_OK. lpDest contains a deep copy of lpSrc.
59  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid,
60  *           MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
61  *
62  * NOTES
63  *  Any elements within the property returned should not be individually
64  *  freed, as they will be freed when lpOrig is.
65  */
66 SCODE WINAPI PropCopyMore(LPSPropValue lpDest, LPSPropValue lpSrc,
67                           ALLOCATEMORE *lpMore, LPVOID lpOrig)
68 {
69     ULONG ulLen, i;
70     SCODE scode = S_OK;
71
72     TRACE("(%p,%p,%p,%p)\n", lpDest, lpSrc, lpMore, lpOrig);
73
74     if (!lpDest || IsBadWritePtr(lpDest, sizeof(SPropValue)) ||
75         FBadProp(lpSrc) || !lpMore)
76         return MAPI_E_INVALID_PARAMETER;
77
78     /* Shallow copy first, this is sufficient for properties without pointers */
79     *lpDest = *lpSrc;
80
81    switch (PROP_TYPE(lpSrc->ulPropTag))
82     {
83     case PT_CLSID:
84         scode = lpMore(sizeof(GUID), lpOrig, (LPVOID*)&lpDest->Value.lpguid);
85         if (SUCCEEDED(scode))
86             *lpDest->Value.lpguid = *lpSrc->Value.lpguid;
87         break;
88     case PT_STRING8:
89         ulLen = lstrlenA(lpSrc->Value.lpszA) + 1u;
90         scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszA);
91         if (SUCCEEDED(scode))
92             memcpy(lpDest->Value.lpszA, lpSrc->Value.lpszA, ulLen);
93         break;
94     case PT_UNICODE:
95         ulLen = (strlenW(lpSrc->Value.lpszW) + 1u) * sizeof(WCHAR);
96         scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszW);
97         if (SUCCEEDED(scode))
98             memcpy(lpDest->Value.lpszW, lpSrc->Value.lpszW, ulLen);
99         break;
100     case PT_BINARY:
101         scode = lpMore(lpSrc->Value.bin.cb, lpOrig, (LPVOID*)&lpDest->Value.bin.lpb);
102         if (SUCCEEDED(scode))
103             memcpy(lpDest->Value.bin.lpb, lpSrc->Value.bin.lpb, lpSrc->Value.bin.cb);
104         break;
105     default:
106         if (lpSrc->ulPropTag & MV_FLAG)
107         {
108             ulLen = UlPropSize(lpSrc);
109
110             if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_STRING8 ||
111                 PROP_TYPE(lpSrc->ulPropTag) == PT_MV_UNICODE)
112             {
113                 /* UlPropSize doesn't account for the string pointers */
114                 ulLen += lpSrc->Value.MVszA.cValues * sizeof(char*);
115             }
116             else if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_BINARY)
117             {
118                /* UlPropSize doesn't account for the SBinary structs */
119                ulLen += lpSrc->Value.MVbin.cValues * sizeof(SBinary);
120             }
121
122             lpDest->Value.MVi.cValues = lpSrc->Value.MVi.cValues;
123             scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.MVi.lpi);
124             if (FAILED(scode))
125                 break;
126
127             /* Note that we could allocate the memory for each value in a
128              * multi-value property separately, however if an allocation failed
129              * we would be left with a bunch of allocated memory, which (while
130              * not really leaked) is unusable until lpOrig is freed. So for
131              * strings and binary arrays we make a single allocation for all
132              * of the data. This is consistent since individual elements can't
133              * be freed anyway.
134              */
135
136             switch (PROP_TYPE(lpSrc->ulPropTag))
137             {
138             case PT_MV_STRING8:
139             {
140                 char *lpNextStr = (char*)(lpDest->Value.MVszA.lppszA +
141                                           lpDest->Value.MVszA.cValues);
142
143                 for (i = 0; i < lpSrc->Value.MVszA.cValues; i++)
144                 {
145                     ULONG ulStrLen = lstrlenA(lpSrc->Value.MVszA.lppszA[i]) + 1u;
146
147                     lpDest->Value.MVszA.lppszA[i] = lpNextStr;
148                     memcpy(lpNextStr, lpSrc->Value.MVszA.lppszA[i], ulStrLen);
149                     lpNextStr += ulStrLen;
150                 }
151                 break;
152             }
153             case PT_MV_UNICODE:
154             {
155                 WCHAR *lpNextStr = (WCHAR*)(lpDest->Value.MVszW.lppszW +
156                                             lpDest->Value.MVszW.cValues);
157
158                 for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
159                 {
160                     ULONG ulStrLen = strlenW(lpSrc->Value.MVszW.lppszW[i]) + 1u;
161
162                     lpDest->Value.MVszW.lppszW[i] = lpNextStr;
163                     memcpy(lpNextStr, lpSrc->Value.MVszW.lppszW[i], ulStrLen * sizeof(WCHAR));
164                     lpNextStr += ulStrLen;
165                 }
166                 break;
167             }
168             case PT_MV_BINARY:
169             {
170                 LPBYTE lpNext = (LPBYTE)(lpDest->Value.MVbin.lpbin +
171                                          lpDest->Value.MVbin.cValues);
172
173                 for (i = 0; i < lpSrc->Value.MVszW.cValues; i++)
174                 {
175                     lpDest->Value.MVbin.lpbin[i].cb = lpSrc->Value.MVbin.lpbin[i].cb;
176                     lpDest->Value.MVbin.lpbin[i].lpb = lpNext;
177                     memcpy(lpNext, lpSrc->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
178                     lpNext += lpDest->Value.MVbin.lpbin[i].cb;
179                 }
180                 break;
181             }
182             default:
183                 /* No embedded pointers, just copy the data over */
184                 memcpy(lpDest->Value.MVi.lpi, lpSrc->Value.MVi.lpi, ulLen);
185                 break;
186             }
187             break;
188         }
189     }
190     return scode;
191 }
192
193 /*************************************************************************
194  * UlPropSize@4 (MAPI32.77)
195  *
196  * Determine the size of a property in bytes.
197  *
198  * PARAMS
199  *  lpProp [I] Property to determine the size of
200  *
201  * RETURNS
202  *  Success: The size of the value in lpProp.
203  *  Failure: 0, if a multi-value (array) property is invalid or the type of lpProp
204  *           is unknown.
205  *
206  * NOTES
207  *  - The size returned does not include the size of the SPropValue struct
208  *    or the size of the array of pointers for multi-valued properties that
209  *    contain pointers (such as PT_MV_STRING8 or PT-MV_UNICODE).
210  *  - MSDN incorrectly states that this function returns MAPI_E_CALL_FAILED if
211  *    lpProp is invalid. In reality no checking is performed and this function
212  *    will crash if passed an invalid property, or return 0 if the property
213  *    type is PT_OBJECT or is unknown.
214  */
215 ULONG WINAPI UlPropSize(LPSPropValue lpProp)
216 {
217     ULONG ulRet = 1u, i;
218
219     TRACE("(%p)\n", lpProp);
220
221     switch (PROP_TYPE(lpProp->ulPropTag))
222     {
223     case PT_MV_I2:       ulRet = lpProp->Value.MVi.cValues;
224     case PT_BOOLEAN:
225     case PT_I2:          ulRet *= sizeof(USHORT);
226                          break;
227     case PT_MV_I4:       ulRet = lpProp->Value.MVl.cValues;
228     case PT_ERROR:
229     case PT_I4:          ulRet *= sizeof(LONG);
230                          break;
231     case PT_MV_I8:       ulRet = lpProp->Value.MVli.cValues;
232     case PT_I8:          ulRet *= sizeof(LONG64);
233                          break;
234     case PT_MV_R4:       ulRet = lpProp->Value.MVflt.cValues;
235     case PT_R4:          ulRet *= sizeof(float);
236                          break;
237     case PT_MV_APPTIME:
238     case PT_MV_R8:       ulRet = lpProp->Value.MVdbl.cValues;
239     case PT_APPTIME:
240     case PT_R8:          ulRet *= sizeof(double);
241                          break;
242     case PT_MV_CURRENCY: ulRet = lpProp->Value.MVcur.cValues;
243     case PT_CURRENCY:    ulRet *= sizeof(CY);
244                          break;
245     case PT_MV_SYSTIME:  ulRet = lpProp->Value.MVft.cValues;
246     case PT_SYSTIME:     ulRet *= sizeof(FILETIME);
247                          break;
248     case PT_MV_CLSID:    ulRet = lpProp->Value.MVguid.cValues;
249     case PT_CLSID:       ulRet *= sizeof(GUID);
250                          break;
251     case PT_MV_STRING8:  ulRet = 0u;
252                          for (i = 0; i < lpProp->Value.MVszA.cValues; i++)
253                              ulRet += (lstrlenA(lpProp->Value.MVszA.lppszA[i]) + 1u);
254                          break;
255     case PT_STRING8:     ulRet = lstrlenA(lpProp->Value.lpszA) + 1u;
256                          break;
257     case PT_MV_UNICODE:  ulRet = 0u;
258                          for (i = 0; i < lpProp->Value.MVszW.cValues; i++)
259                              ulRet += (strlenW(lpProp->Value.MVszW.lppszW[i]) + 1u);
260                          ulRet *= sizeof(WCHAR);
261                          break;
262     case PT_UNICODE:     ulRet = (lstrlenW(lpProp->Value.lpszW) + 1u) * sizeof(WCHAR);
263                          break;
264     case PT_MV_BINARY:   ulRet = 0u;
265                          for (i = 0; i < lpProp->Value.MVbin.cValues; i++)
266                              ulRet += lpProp->Value.MVbin.lpbin[i].cb;
267                          break;
268     case PT_BINARY:      ulRet = lpProp->Value.bin.cb;
269                          break;
270     case PT_OBJECT:
271     default:             ulRet = 0u;
272                          break;
273     }
274
275     return ulRet;
276 }
277
278 /*************************************************************************
279  * FPropContainsProp@12 (MAPI32.78)
280  *
281  * Find a property with a given property tag in a property array.
282  *
283  * PARAMS
284  *  lpHaystack [I] Property to match to
285  *  lpNeedle   [I] Property to find in lpHaystack
286  *  ulFuzzy    [I] Flags controlling match type and strictness (FL_* flags from "mapidefs.h")
287  *
288  * RETURNS
289  *  TRUE, if lpNeedle matches lpHaystack according to the criteria of ulFuzzy.
290  *
291  * NOTES
292  *  Only property types of PT_STRING8 and PT_BINARY are handled by this function.
293  */
294 BOOL WINAPI FPropContainsProp(LPSPropValue lpHaystack, LPSPropValue lpNeedle, ULONG ulFuzzy)
295 {
296     TRACE("(%p,%p,0x%08x)\n", lpHaystack, lpNeedle, ulFuzzy);
297
298     if (FBadProp(lpHaystack) || FBadProp(lpNeedle) ||
299         PROP_TYPE(lpHaystack->ulPropTag) != PROP_TYPE(lpNeedle->ulPropTag))
300         return FALSE;
301
302     /* FIXME: Do later versions support Unicode as well? */
303
304     if (PROP_TYPE(lpHaystack->ulPropTag) == PT_STRING8)
305     {
306         DWORD dwFlags = 0, dwNeedleLen, dwHaystackLen;
307
308         if (ulFuzzy & FL_IGNORECASE)
309             dwFlags |= NORM_IGNORECASE;
310         if (ulFuzzy & FL_IGNORENONSPACE)
311             dwFlags |= NORM_IGNORENONSPACE;
312         if (ulFuzzy & FL_LOOSE)
313             dwFlags |= (NORM_IGNORECASE|NORM_IGNORENONSPACE|NORM_IGNORESYMBOLS);
314
315         dwNeedleLen = lstrlenA(lpNeedle->Value.lpszA);
316         dwHaystackLen = lstrlenA(lpHaystack->Value.lpszA);
317
318         if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
319         {
320             if (dwNeedleLen <= dwHaystackLen &&
321                 CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
322                                lpHaystack->Value.lpszA, dwNeedleLen,
323                                lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
324                 return TRUE; /* needle is a prefix of haystack */
325         }
326         else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
327         {
328             LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD) = StrChrA;
329             LPSTR lpStr = lpHaystack->Value.lpszA;
330
331             if (dwFlags & NORM_IGNORECASE)
332                 pStrChrFn = StrChrIA;
333
334             while ((lpStr = pStrChrFn(lpStr, *lpNeedle->Value.lpszA)) != NULL)
335             {
336                 dwHaystackLen -= (lpStr - lpHaystack->Value.lpszA);
337                 if (dwNeedleLen <= dwHaystackLen &&
338                     CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
339                                lpStr, dwNeedleLen,
340                                lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
341                     return TRUE; /* needle is a substring of haystack */
342                 lpStr++;
343             }
344         }
345         else if (CompareStringA(LOCALE_USER_DEFAULT, dwFlags,
346                                 lpHaystack->Value.lpszA, dwHaystackLen,
347                                 lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL)
348             return TRUE; /* full string match */
349     }
350     else if (PROP_TYPE(lpHaystack->ulPropTag) == PT_BINARY)
351     {
352         if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX)
353         {
354             if (lpNeedle->Value.bin.cb <= lpHaystack->Value.bin.cb &&
355                 !memcmp(lpNeedle->Value.bin.lpb, lpHaystack->Value.bin.lpb,
356                         lpNeedle->Value.bin.cb))
357                 return TRUE; /* needle is a prefix of haystack */
358         }
359         else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING)
360         {
361             ULONG ulLen = lpHaystack->Value.bin.cb;
362             LPBYTE lpb = lpHaystack->Value.bin.lpb;
363
364             while ((lpb = memchr(lpb, *lpNeedle->Value.bin.lpb, ulLen)) != NULL)
365             {
366                 ulLen = lpHaystack->Value.bin.cb - (lpb - lpHaystack->Value.bin.lpb);
367                 if (lpNeedle->Value.bin.cb <= ulLen &&
368                     !memcmp(lpNeedle->Value.bin.lpb, lpb, lpNeedle->Value.bin.cb))
369                     return TRUE; /* needle is a substring of haystack */
370                 lpb++;
371             }
372         }
373         else if (!LPropCompareProp(lpHaystack, lpNeedle))
374             return TRUE; /* needle is an exact match with haystack */
375
376     }
377     return FALSE;
378 }
379
380 /*************************************************************************
381  * FPropCompareProp@12 (MAPI32.79)
382  *
383  * Compare two properties.
384  *
385  * PARAMS
386  *  lpPropLeft  [I] Left hand property to compare to lpPropRight
387  *  ulOp        [I] Comparison operator (RELOP_* enum from "mapidefs.h")
388  *  lpPropRight [I] Right hand property to compare to lpPropLeft
389  *
390  * RETURNS
391  *  TRUE, if the comparison is true, FALSE otherwise.
392  */
393 BOOL WINAPI FPropCompareProp(LPSPropValue lpPropLeft, ULONG ulOp, LPSPropValue lpPropRight)
394 {
395     LONG iCmp;
396
397     TRACE("(%p,%d,%p)\n", lpPropLeft, ulOp, lpPropRight);
398
399     if (ulOp > RELOP_RE || FBadProp(lpPropLeft) || FBadProp(lpPropRight))
400         return FALSE;
401
402     if (ulOp == RELOP_RE)
403     {
404         FIXME("Comparison operator RELOP_RE not yet implemented!\n");
405         return FALSE;
406     }
407
408     iCmp = LPropCompareProp(lpPropLeft, lpPropRight);
409
410     switch (ulOp)
411     {
412     case RELOP_LT: return iCmp <  0 ? TRUE : FALSE;
413     case RELOP_LE: return iCmp <= 0 ? TRUE : FALSE;
414     case RELOP_GT: return iCmp >  0 ? TRUE : FALSE;
415     case RELOP_GE: return iCmp >= 0 ? TRUE : FALSE;
416     case RELOP_EQ: return iCmp == 0 ? TRUE : FALSE;
417     case RELOP_NE: return iCmp != 0 ? TRUE : FALSE;
418     }
419     return FALSE;
420 }
421
422 /*************************************************************************
423  * LPropCompareProp@8 (MAPI32.80)
424  *
425  * Compare two properties.
426  *
427  * PARAMS
428  *  lpPropLeft  [I] Left hand property to compare to lpPropRight
429  *  lpPropRight [I] Right hand property to compare to lpPropLeft
430  *
431  * RETURNS
432  *  An integer less than, equal to or greater than 0, indicating that
433  *  lpszStr is less than, the same, or greater than lpszComp.
434  */
435 LONG WINAPI LPropCompareProp(LPSPropValue lpPropLeft, LPSPropValue lpPropRight)
436 {
437     LONG iRet;
438
439     TRACE("(%p->0x%08x,%p->0x%08x)\n", lpPropLeft, lpPropLeft->ulPropTag,
440           lpPropRight, lpPropRight->ulPropTag);
441
442     /* If the properties are not the same, sort by property type */
443     if (PROP_TYPE(lpPropLeft->ulPropTag) != PROP_TYPE(lpPropRight->ulPropTag))
444         return (LONG)PROP_TYPE(lpPropLeft->ulPropTag) - (LONG)PROP_TYPE(lpPropRight->ulPropTag);
445
446     switch (PROP_TYPE(lpPropLeft->ulPropTag))
447     {
448     case PT_UNSPECIFIED:
449     case PT_NULL:
450         return 0; /* NULLs are equal */
451     case PT_I2:
452         return lpPropLeft->Value.i - lpPropRight->Value.i;
453     case PT_I4:
454         return lpPropLeft->Value.l - lpPropRight->Value.l;
455     case PT_I8:
456         if (lpPropLeft->Value.li.QuadPart > lpPropRight->Value.li.QuadPart)
457             return 1;
458         if (lpPropLeft->Value.li.QuadPart == lpPropRight->Value.li.QuadPart)
459             return 0;
460         return -1;
461     case PT_R4:
462         if (lpPropLeft->Value.flt > lpPropRight->Value.flt)
463             return 1;
464         if (lpPropLeft->Value.flt == lpPropRight->Value.flt)
465             return 0;
466         return -1;
467     case PT_APPTIME:
468     case PT_R8:
469         if (lpPropLeft->Value.dbl > lpPropRight->Value.dbl)
470             return 1;
471         if (lpPropLeft->Value.dbl == lpPropRight->Value.dbl)
472             return 0;
473         return -1;
474     case PT_CURRENCY:
475         if (lpPropLeft->Value.cur.int64 > lpPropRight->Value.cur.int64)
476             return 1;
477         if (lpPropLeft->Value.cur.int64 == lpPropRight->Value.cur.int64)
478             return 0;
479         return -1;
480     case PT_SYSTIME:
481         return CompareFileTime(&lpPropLeft->Value.ft, &lpPropRight->Value.ft);
482     case PT_BOOLEAN:
483         return (lpPropLeft->Value.b ? 1 : 0) - (lpPropRight->Value.b ? 1 : 0);
484     case PT_BINARY:
485         if (lpPropLeft->Value.bin.cb == lpPropRight->Value.bin.cb)
486             iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
487                           lpPropLeft->Value.bin.cb);
488         else
489         {
490             iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb,
491                           min(lpPropLeft->Value.bin.cb, lpPropRight->Value.bin.cb));
492
493             if (!iRet)
494                 iRet = lpPropLeft->Value.bin.cb - lpPropRight->Value.bin.cb;
495         }
496         return iRet;
497     case PT_STRING8:
498         return lstrcmpA(lpPropLeft->Value.lpszA, lpPropRight->Value.lpszA);
499     case PT_UNICODE:
500         return strcmpW(lpPropLeft->Value.lpszW, lpPropRight->Value.lpszW);
501     case PT_ERROR:
502         if (lpPropLeft->Value.err > lpPropRight->Value.err)
503             return 1;
504         if (lpPropLeft->Value.err == lpPropRight->Value.err)
505             return 0;
506         return -1;
507     case PT_CLSID:
508         return memcmp(lpPropLeft->Value.lpguid, lpPropRight->Value.lpguid,
509                       sizeof(GUID));
510     }
511     FIXME("Unhandled property type %d\n", PROP_TYPE(lpPropLeft->ulPropTag));
512     return 0;
513 }
514
515 /*************************************************************************
516  * HrGetOneProp@8 (MAPI32.135)
517  *
518  * Get a property value from an IMAPIProp object.
519  *
520  * PARAMS
521  *  lpIProp   [I] IMAPIProp object to get the property value in
522  *  ulPropTag [I] Property tag of the property to get
523  *  lppProp   [O] Destination for the returned property
524  *
525  * RETURNS
526  *  Success: S_OK. *lppProp contains the property value requested.
527  *  Failure: MAPI_E_NOT_FOUND, if no property value has the tag given by ulPropTag.
528  */
529 HRESULT WINAPI HrGetOneProp(LPMAPIPROP lpIProp, ULONG ulPropTag, LPSPropValue *lppProp)
530 {
531     SPropTagArray pta;
532     ULONG ulCount;
533     HRESULT hRet;
534
535     TRACE("(%p,%d,%p)\n", lpIProp, ulPropTag, lppProp);
536
537     pta.cValues = 1u;
538     pta.aulPropTag[0] = ulPropTag;
539     hRet = IMAPIProp_GetProps(lpIProp, &pta, 0u, &ulCount, lppProp);
540     if (hRet == MAPI_W_ERRORS_RETURNED)
541     {
542         MAPIFreeBuffer(*lppProp);
543         *lppProp = NULL;
544         hRet = MAPI_E_NOT_FOUND;
545     }
546     return hRet;
547 }
548
549 /*************************************************************************
550  * HrSetOneProp@8 (MAPI32.136)
551  *
552  * Set a property value in an IMAPIProp object.
553  *
554  * PARAMS
555  *  lpIProp [I] IMAPIProp object to set the property value in
556  *  lpProp  [I] Property value to set
557  *
558  * RETURNS
559  *  Success: S_OK. The value in lpProp is set in lpIProp.
560  *  Failure: An error result from IMAPIProp_SetProps().
561  */
562 HRESULT WINAPI HrSetOneProp(LPMAPIPROP lpIProp, LPSPropValue lpProp)
563 {
564     TRACE("(%p,%p)\n", lpIProp, lpProp);
565
566     return IMAPIProp_SetProps(lpIProp, 1u, lpProp, NULL);
567 }
568
569 /*************************************************************************
570  * FPropExists@8 (MAPI32.137)
571  *
572  * Find a property with a given property tag in an IMAPIProp object.
573  *
574  * PARAMS
575  *  lpIProp   [I] IMAPIProp object to find the property tag in
576  *  ulPropTag [I] Property tag to find
577  *
578  * RETURNS
579  *  TRUE, if ulPropTag matches a property held in lpIProp,
580  *  FALSE, otherwise.
581  *
582  * NOTES
583  *  if ulPropTag has a property type of PT_UNSPECIFIED, then only the property
584  *  Ids need to match for a successful match to occur.
585  */
586  BOOL WINAPI FPropExists(LPMAPIPROP lpIProp, ULONG ulPropTag)
587  {
588     BOOL bRet = FALSE;
589
590     TRACE("(%p,%d)\n", lpIProp, ulPropTag);
591
592     if (lpIProp)
593     {
594         LPSPropTagArray lpTags;
595         ULONG i;
596
597         if (FAILED(IMAPIProp_GetPropList(lpIProp, 0u, &lpTags)))
598             return FALSE;
599
600         for (i = 0; i < lpTags->cValues; i++)
601         {
602             if (!FBadPropTag(lpTags->aulPropTag[i]) &&
603                 (lpTags->aulPropTag[i] == ulPropTag ||
604                  (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
605                   PROP_ID(lpTags->aulPropTag[i]) == lpTags->aulPropTag[i])))
606             {
607                 bRet = TRUE;
608                 break;
609             }
610         }
611         MAPIFreeBuffer(lpTags);
612     }
613     return bRet;
614 }
615
616 /*************************************************************************
617  * PpropFindProp@12 (MAPI32.138)
618  *
619  * Find a property with a given property tag in a property array.
620  *
621  * PARAMS
622  *  lpProps   [I] Property array to search
623  *  cValues   [I] Number of properties in lpProps
624  *  ulPropTag [I] Property tag to find
625  *
626  * RETURNS
627  *  A pointer to the matching property, or NULL if none was found.
628  *
629  * NOTES
630  *  if ulPropTag has a property type of PT_UNSPECIFIED, then only the property
631  *  Ids need to match for a successful match to occur.
632  */
633 LPSPropValue WINAPI PpropFindProp(LPSPropValue lpProps, ULONG cValues, ULONG ulPropTag)
634 {
635     TRACE("(%p,%d,%d)\n", lpProps, cValues, ulPropTag);
636
637     if (lpProps && cValues)
638     {
639         ULONG i;
640         for (i = 0; i < cValues; i++)
641         {
642             if (!FBadPropTag(lpProps[i].ulPropTag) &&
643                 (lpProps[i].ulPropTag == ulPropTag ||
644                  (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED &&
645                   PROP_ID(lpProps[i].ulPropTag) == PROP_ID(ulPropTag))))
646                 return &lpProps[i];
647         }
648     }
649     return NULL;
650 }
651
652 /*************************************************************************
653  * FreePadrlist@4 (MAPI32.139)
654  *
655  * Free the memory used by an address book list.
656  *
657  * PARAMS
658  *  lpAddrs [I] Address book list to free
659  *
660  * RETURNS
661  *  Nothing.
662  */
663 VOID WINAPI FreePadrlist(LPADRLIST lpAddrs)
664 {
665     TRACE("(%p)\n", lpAddrs);
666
667     /* Structures are binary compatible; use the same implementation */
668     FreeProws((LPSRowSet)lpAddrs);
669 }
670
671 /*************************************************************************
672  * FreeProws@4 (MAPI32.140)
673  *
674  * Free the memory used by a row set.
675  *
676  * PARAMS
677  *  lpRowSet [I] Row set to free
678  *
679  * RETURNS
680  *  Nothing.
681  */
682 VOID WINAPI FreeProws(LPSRowSet lpRowSet)
683 {
684     TRACE("(%p)\n", lpRowSet);
685
686     if (lpRowSet)
687     {
688         ULONG i;
689
690         for (i = 0; i < lpRowSet->cRows; i++)
691             MAPIFreeBuffer(lpRowSet->aRow[i].lpProps);
692
693         MAPIFreeBuffer(lpRowSet);
694     }
695 }
696
697 /*************************************************************************
698  * ScCountProps@12 (MAPI32.170)
699  *
700  * Validate and determine the length of an array of properties.
701  *
702  * PARAMS
703  *  iCount  [I] Length of the lpProps array
704  *  lpProps [I] Array of properties to validate/size
705  *  pcBytes [O] If non-NULL, destination for the size of the property array
706  *
707  * RETURNS
708  *  Success: S_OK. If pcBytes is non-NULL, it contains the size of the propery array.
709  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid or validation
710  *           of the property array fails.
711  */
712 SCODE WINAPI ScCountProps(INT iCount, LPSPropValue lpProps, ULONG *pcBytes)
713 {
714     ULONG i, ulCount = iCount, ulBytes = 0;
715
716     TRACE("(%d,%p,%p)\n", iCount, lpProps, pcBytes);
717
718     if (iCount <= 0 || !lpProps ||
719         IsBadReadPtr(lpProps, iCount * sizeof(SPropValue)))
720         return MAPI_E_INVALID_PARAMETER;
721
722     for (i = 0; i < ulCount; i++)
723     {
724         ULONG ulPropSize = 0;
725
726         if (FBadProp(&lpProps[i]) || lpProps[i].ulPropTag == PROP_ID_NULL ||
727             lpProps[i].ulPropTag == PROP_ID_INVALID)
728             return MAPI_E_INVALID_PARAMETER;
729
730             if (PROP_TYPE(lpProps[i].ulPropTag) != PT_OBJECT)
731             {
732                 ulPropSize = UlPropSize(&lpProps[i]);
733                 if (!ulPropSize)
734                     return MAPI_E_INVALID_PARAMETER;
735             }
736
737             switch (PROP_TYPE(lpProps[i].ulPropTag))
738             {
739             case PT_STRING8:
740             case PT_UNICODE:
741             case PT_CLSID:
742             case PT_BINARY:
743             case PT_MV_I2:
744             case PT_MV_I4:
745             case PT_MV_I8:
746             case PT_MV_R4:
747             case PT_MV_R8:
748             case PT_MV_CURRENCY:
749             case PT_MV_SYSTIME:
750             case PT_MV_APPTIME:
751                 ulPropSize += sizeof(SPropValue);
752                 break;
753             case PT_MV_CLSID:
754                 ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue);
755                 break;
756             case PT_MV_STRING8:
757             case PT_MV_UNICODE:
758                 ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue);
759                 break;
760             case PT_MV_BINARY:
761                 ulPropSize += lpProps[i].Value.MVbin.cValues * sizeof(SBinary) + sizeof(SPropValue);
762                 break;
763             default:
764                 ulPropSize = sizeof(SPropValue);
765                 break;
766             }
767             ulBytes += ulPropSize;
768     }
769     if (pcBytes)
770         *pcBytes = ulBytes;
771
772     return S_OK;
773 }
774
775 /*************************************************************************
776  * ScCopyProps@16 (MAPI32.171)
777  *
778  * Copy an array of property values into a buffer suited for serialisation.
779  *
780  * PARAMS
781  *  cValues   [I] Number of properties in lpProps
782  *  lpProps   [I] Property array to copy
783  *  lpDst     [O] Destination for the serialised data
784  *  lpCount   [O] If non-NULL, destination for the number of bytes of data written to lpDst
785  *
786  * RETURNS
787  *  Success: S_OK. lpDst contains the serialised data from lpProps.
788  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
789  *
790  * NOTES
791  *  The resulting property value array is stored in a contiguous block starting at lpDst.
792  */
793 SCODE WINAPI ScCopyProps(int cValues, LPSPropValue lpProps, LPVOID lpDst, ULONG *lpCount)
794 {
795     LPSPropValue lpDest = (LPSPropValue)lpDst;
796     char *lpDataDest = (char *)(lpDest + cValues);
797     ULONG ulLen, i;
798     int iter;
799
800     TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpDst, lpCount);
801
802     if (!lpProps || cValues < 0 || !lpDest)
803         return MAPI_E_INVALID_PARAMETER;
804
805     memcpy(lpDst, lpProps, cValues * sizeof(SPropValue));
806
807     for (iter = 0; iter < cValues; iter++)
808     {
809         switch (PROP_TYPE(lpProps->ulPropTag))
810         {
811         case PT_CLSID:
812             lpDest->Value.lpguid = (LPGUID)lpDataDest;
813             *lpDest->Value.lpguid = *lpProps->Value.lpguid;
814             lpDataDest += sizeof(GUID);
815             break;
816         case PT_STRING8:
817             ulLen = lstrlenA(lpProps->Value.lpszA) + 1u;
818             lpDest->Value.lpszA = lpDataDest;
819             memcpy(lpDest->Value.lpszA, lpProps->Value.lpszA, ulLen);
820             lpDataDest += ulLen;
821             break;
822         case PT_UNICODE:
823             ulLen = (strlenW(lpProps->Value.lpszW) + 1u) * sizeof(WCHAR);
824             lpDest->Value.lpszW = (LPWSTR)lpDataDest;
825             memcpy(lpDest->Value.lpszW, lpProps->Value.lpszW, ulLen);
826             lpDataDest += ulLen;
827             break;
828         case PT_BINARY:
829             lpDest->Value.bin.lpb = (LPBYTE)lpDataDest;
830             memcpy(lpDest->Value.bin.lpb, lpProps->Value.bin.lpb, lpProps->Value.bin.cb);
831             lpDataDest += lpProps->Value.bin.cb;
832             break;
833         default:
834             if (lpProps->ulPropTag & MV_FLAG)
835             {
836                 lpDest->Value.MVi.cValues = lpProps->Value.MVi.cValues;
837                 /* Note: Assignment uses lppszA but covers all cases by union aliasing */
838                 lpDest->Value.MVszA.lppszA = (char**)lpDataDest;
839
840                 switch (PROP_TYPE(lpProps->ulPropTag))
841                 {
842                 case PT_MV_STRING8:
843                 {
844                     lpDataDest += lpProps->Value.MVszA.cValues * sizeof(char *);
845
846                     for (i = 0; i < lpProps->Value.MVszA.cValues; i++)
847                     {
848                         ULONG ulStrLen = lstrlenA(lpProps->Value.MVszA.lppszA[i]) + 1u;
849
850                         lpDest->Value.MVszA.lppszA[i] = lpDataDest;
851                         memcpy(lpDataDest, lpProps->Value.MVszA.lppszA[i], ulStrLen);
852                         lpDataDest += ulStrLen;
853                     }
854                     break;
855                 }
856                 case PT_MV_UNICODE:
857                 {
858                     lpDataDest += lpProps->Value.MVszW.cValues * sizeof(WCHAR *);
859
860                     for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
861                     {
862                         ULONG ulStrLen = (strlenW(lpProps->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
863
864                         lpDest->Value.MVszW.lppszW[i] = (LPWSTR)lpDataDest;
865                         memcpy(lpDataDest, lpProps->Value.MVszW.lppszW[i], ulStrLen);
866                         lpDataDest += ulStrLen;
867                     }
868                     break;
869                 }
870                 case PT_MV_BINARY:
871                 {
872                     lpDataDest += lpProps->Value.MVszW.cValues * sizeof(SBinary);
873
874                     for (i = 0; i < lpProps->Value.MVszW.cValues; i++)
875                     {
876                         lpDest->Value.MVbin.lpbin[i].cb = lpProps->Value.MVbin.lpbin[i].cb;
877                         lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)lpDataDest;
878                         memcpy(lpDataDest, lpProps->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb);
879                         lpDataDest += lpDest->Value.MVbin.lpbin[i].cb;
880                     }
881                     break;
882                 }
883                 default:
884                     /* No embedded pointers, just copy the data over */
885                     ulLen = UlPropSize(lpProps);
886                     memcpy(lpDest->Value.MVi.lpi, lpProps->Value.MVi.lpi, ulLen);
887                     lpDataDest += ulLen;
888                     break;
889                 }
890                 break;
891             }
892         }
893         lpDest++;
894         lpProps++;
895     }
896     if (lpCount)
897         *lpCount = lpDataDest - (char *)lpDst;
898
899     return S_OK;
900 }
901
902 /*************************************************************************
903  * ScRelocProps@20 (MAPI32.172)
904  *
905  * Relocate the pointers in an array of property values after it has been copied.
906  *
907  * PARAMS
908  *  cValues   [I] Number of properties in lpProps
909  *  lpProps   [O] Property array to relocate the pointers in.
910  *  lpOld     [I] Position where the data was copied from
911  *  lpNew     [I] Position where the data was copied to
912  *  lpCount   [O] If non-NULL, destination for the number of bytes of data at lpDst
913  *
914  * RETURNS
915  *  Success: S_OK. Any pointers in lpProps are relocated.
916  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
917  *
918  * NOTES
919  *  MSDN states that this function can be used for serialisation by passing
920  *  NULL as either lpOld or lpNew, thus converting any pointers in lpProps
921  *  between offsets and pointers. This does not work in native (it crashes),
922  *  and cannot be made to work in Wine because the original interface design
923  *  is deficient. The only use left for this function is to remap pointers
924  *  in a contiguous property array that has been copied with memcpy() to
925  *  another memory location.
926  */
927 SCODE WINAPI ScRelocProps(int cValues, LPSPropValue lpProps, LPVOID lpOld,
928                           LPVOID lpNew, ULONG *lpCount)
929 {
930     static const BOOL bBadPtr = TRUE; /* Windows bug - Assumes source is bad */
931     LPSPropValue lpDest = lpProps;
932     ULONG ulCount = cValues * sizeof(SPropValue);
933     ULONG ulLen, i;
934     int iter;
935
936     TRACE("(%d,%p,%p,%p,%p)\n", cValues, lpProps, lpOld, lpNew, lpCount);
937
938     if (!lpProps || cValues < 0 || !lpOld || !lpNew)
939         return MAPI_E_INVALID_PARAMETER;
940
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!
947      *
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. It seems this
952      * functionality was never tested by MS.
953      */
954
955 #define RELOC_PTR(p) (((char*)(p)) - (char*)lpOld + (char*)lpNew)
956
957     for (iter = 0; iter < cValues; iter++)
958     {
959         switch (PROP_TYPE(lpDest->ulPropTag))
960         {
961         case PT_CLSID:
962             lpDest->Value.lpguid = (LPGUID)RELOC_PTR(lpDest->Value.lpguid);
963             ulCount += sizeof(GUID);
964             break;
965         case PT_STRING8:
966             ulLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.lpszA) + 1u;
967             lpDest->Value.lpszA = RELOC_PTR(lpDest->Value.lpszA);
968             if (bBadPtr)
969                 ulLen = lstrlenA(lpDest->Value.lpszA) + 1u;
970             ulCount += ulLen;
971             break;
972         case PT_UNICODE:
973             ulLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
974             lpDest->Value.lpszW = (LPWSTR)RELOC_PTR(lpDest->Value.lpszW);
975             if (bBadPtr)
976                 ulLen = (strlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR);
977             ulCount += ulLen;
978             break;
979         case PT_BINARY:
980             lpDest->Value.bin.lpb = (LPBYTE)RELOC_PTR(lpDest->Value.bin.lpb);
981             ulCount += lpDest->Value.bin.cb;
982             break;
983         default:
984             if (lpDest->ulPropTag & MV_FLAG)
985             {
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)
988                  */
989                 if (bBadPtr)
990                     lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
991
992                 switch (PROP_TYPE(lpProps->ulPropTag))
993                 {
994                 case PT_MV_STRING8:
995                 {
996                     ulCount += lpDest->Value.MVszA.cValues * sizeof(char *);
997
998                     for (i = 0; i < lpDest->Value.MVszA.cValues; i++)
999                     {
1000                         ULONG ulStrLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
1001
1002                         lpDest->Value.MVszA.lppszA[i] = RELOC_PTR(lpDest->Value.MVszA.lppszA[i]);
1003                         if (bBadPtr)
1004                             ulStrLen = lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u;
1005                         ulCount += ulStrLen;
1006                     }
1007                     break;
1008                 }
1009                 case PT_MV_UNICODE:
1010                 {
1011                     ulCount += lpDest->Value.MVszW.cValues * sizeof(WCHAR *);
1012
1013                     for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
1014                     {
1015                         ULONG ulStrLen = bBadPtr ? 0 : (strlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
1016
1017                         lpDest->Value.MVszW.lppszW[i] = (LPWSTR)RELOC_PTR(lpDest->Value.MVszW.lppszW[i]);
1018                         if (bBadPtr)
1019                             ulStrLen = (strlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR);
1020                         ulCount += ulStrLen;
1021                     }
1022                     break;
1023                 }
1024                 case PT_MV_BINARY:
1025                 {
1026                     ulCount += lpDest->Value.MVszW.cValues * sizeof(SBinary);
1027
1028                     for (i = 0; i < lpDest->Value.MVszW.cValues; i++)
1029                     {
1030                         lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)RELOC_PTR(lpDest->Value.MVbin.lpbin[i].lpb);
1031                         ulCount += lpDest->Value.MVbin.lpbin[i].cb;
1032                     }
1033                     break;
1034                 }
1035                 default:
1036                     ulCount += UlPropSize(lpDest);
1037                     break;
1038                 }
1039                 if (!bBadPtr)
1040                     lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA);
1041                 break;
1042             }
1043         }
1044         lpDest++;
1045     }
1046     if (lpCount)
1047         *lpCount = ulCount;
1048
1049     return S_OK;
1050 }
1051
1052 /*************************************************************************
1053  * LpValFindProp@12 (MAPI32.173)
1054  *
1055  * Find a property with a given property id in a property array.
1056  *
1057  * PARAMS
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
1061  *
1062  * RETURNS
1063  *  A pointer to the matching property, or NULL if none was found.
1064  *
1065  * NOTES
1066  *  This function matches only on the property id and does not care if the
1067  *  property types differ.
1068  */
1069 LPSPropValue WINAPI LpValFindProp(ULONG ulPropTag, ULONG cValues, LPSPropValue lpProps)
1070 {
1071     TRACE("(%d,%d,%p)\n", ulPropTag, cValues, lpProps);
1072
1073     if (lpProps && cValues)
1074     {
1075         ULONG i;
1076         for (i = 0; i < cValues; i++)
1077         {
1078             if (PROP_ID(ulPropTag) == PROP_ID(lpProps[i].ulPropTag))
1079                 return &lpProps[i];
1080         }
1081     }
1082     return NULL;
1083 }
1084
1085 /*************************************************************************
1086  * ScDupPropset@16 (MAPI32.174)
1087  *
1088  * Duplicate a property value array into a contiguous block of memory.
1089  *
1090  * PARAMS
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
1095  *
1096  * RETURNS
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.
1100  */
1101 SCODE WINAPI ScDupPropset(int cValues, LPSPropValue lpProps,
1102                           LPALLOCATEBUFFER lpAlloc, LPSPropValue *lpNewProp)
1103 {
1104     ULONG ulCount;
1105     SCODE sc;
1106
1107     TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpAlloc, lpNewProp);
1108
1109     sc = ScCountProps(cValues, lpProps, &ulCount);
1110     if (SUCCEEDED(sc))
1111     {
1112         sc = lpAlloc(ulCount, (LPVOID*)lpNewProp);
1113         if (SUCCEEDED(sc))
1114             sc = ScCopyProps(cValues, lpProps, *lpNewProp, &ulCount);
1115     }
1116     return sc;
1117 }
1118
1119 /*************************************************************************
1120  * FBadRglpszA@8 (MAPI32.175)
1121  *
1122  * Determine if an array of strings is invalid
1123  *
1124  * PARAMS
1125  *  lppszStrs [I] Array of strings to check
1126  *  ulCount   [I] Number of strings in lppszStrs
1127  *
1128  * RETURNS
1129  *  TRUE, if lppszStrs is invalid, FALSE otherwise.
1130  */
1131 BOOL WINAPI FBadRglpszA(LPSTR *lppszStrs, ULONG ulCount)
1132 {
1133     ULONG i;
1134
1135     TRACE("(%p,%d)\n", lppszStrs, ulCount);
1136
1137     if (!ulCount)
1138         return FALSE;
1139
1140     if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR)))
1141         return TRUE;
1142
1143     for (i = 0; i < ulCount; i++)
1144     {
1145         if (!lppszStrs[i] || IsBadStringPtrA(lppszStrs[i], -1))
1146             return TRUE;
1147     }
1148     return FALSE;
1149 }
1150
1151 /*************************************************************************
1152  * FBadRglpszW@8 (MAPI32.176)
1153  *
1154  * See FBadRglpszA.
1155  */
1156 BOOL WINAPI FBadRglpszW(LPWSTR *lppszStrs, ULONG ulCount)
1157 {
1158     ULONG i;
1159
1160     TRACE("(%p,%d)\n", lppszStrs, ulCount);
1161
1162     if (!ulCount)
1163         return FALSE;
1164
1165     if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR)))
1166         return TRUE;
1167
1168     for (i = 0; i < ulCount; i++)
1169     {
1170         if (!lppszStrs[i] || IsBadStringPtrW(lppszStrs[i], -1))
1171             return TRUE;
1172     }
1173     return FALSE;
1174 }
1175
1176 /*************************************************************************
1177  * FBadRowSet@4 (MAPI32.177)
1178  *
1179  * Determine if a row is invalid
1180  *
1181  * PARAMS
1182  *  lpRow [I] Row to check
1183  *
1184  * RETURNS
1185  *  TRUE, if lpRow is invalid, FALSE otherwise.
1186  */
1187 BOOL WINAPI FBadRowSet(LPSRowSet lpRowSet)
1188 {
1189     ULONG i;
1190     TRACE("(%p)\n", lpRowSet);
1191
1192     if (!lpRowSet || IsBadReadPtr(lpRowSet, CbSRowSet(lpRowSet)))
1193         return TRUE;
1194
1195     for (i = 0; i < lpRowSet->cRows; i++)
1196     {
1197         if (FBadRow(&lpRowSet->aRow[i]))
1198             return TRUE;
1199     }
1200     return FALSE;
1201 }
1202
1203 /*************************************************************************
1204  * FBadPropTag@4 (MAPI32.179)
1205  *
1206  * Determine if a property tag is invalid
1207  *
1208  * PARAMS
1209  *  ulPropTag [I] Property tag to check
1210  *
1211  * RETURNS
1212  *  TRUE, if ulPropTag is invalid, FALSE otherwise.
1213  */
1214 ULONG WINAPI FBadPropTag(ULONG ulPropTag)
1215 {
1216     TRACE("(0x%08x)\n", ulPropTag);
1217
1218     switch (ulPropTag & (~MV_FLAG & PROP_TYPE_MASK))
1219     {
1220     case PT_UNSPECIFIED:
1221     case PT_NULL:
1222     case PT_I2:
1223     case PT_LONG:
1224     case PT_R4:
1225     case PT_DOUBLE:
1226     case PT_CURRENCY:
1227     case PT_APPTIME:
1228     case PT_ERROR:
1229     case PT_BOOLEAN:
1230     case PT_OBJECT:
1231     case PT_I8:
1232     case PT_STRING8:
1233     case PT_UNICODE:
1234     case PT_SYSTIME:
1235     case PT_CLSID:
1236     case PT_BINARY:
1237         return FALSE;
1238     }
1239     return TRUE;
1240 }
1241
1242 /*************************************************************************
1243  * FBadRow@4 (MAPI32.180)
1244  *
1245  * Determine if a row is invalid
1246  *
1247  * PARAMS
1248  *  lpRow [I] Row to check
1249  *
1250  * RETURNS
1251  *  TRUE, if lpRow is invalid, FALSE otherwise.
1252  */
1253 ULONG WINAPI FBadRow(LPSRow lpRow)
1254 {
1255     ULONG i;
1256     TRACE("(%p)\n", lpRow);
1257
1258     if (!lpRow || IsBadReadPtr(lpRow, sizeof(SRow)) || !lpRow->lpProps ||
1259         IsBadReadPtr(lpRow->lpProps, lpRow->cValues * sizeof(SPropValue)))
1260         return TRUE;
1261
1262     for (i = 0; i < lpRow->cValues; i++)
1263     {
1264         if (FBadProp(&lpRow->lpProps[i]))
1265             return TRUE;
1266     }
1267     return FALSE;
1268 }
1269
1270 /*************************************************************************
1271  * FBadProp@4 (MAPI32.181)
1272  *
1273  * Determine if a property is invalid
1274  *
1275  * PARAMS
1276  *  lpProp [I] Property to check
1277  *
1278  * RETURNS
1279  *  TRUE, if lpProp is invalid, FALSE otherwise.
1280  */
1281 ULONG WINAPI FBadProp(LPSPropValue lpProp)
1282 {
1283     if (!lpProp || IsBadReadPtr(lpProp, sizeof(SPropValue)) ||
1284         FBadPropTag(lpProp->ulPropTag))
1285         return TRUE;
1286
1287     switch (PROP_TYPE(lpProp->ulPropTag))
1288     {
1289     /* Single value properties containing pointers */
1290     case PT_STRING8:
1291         if (!lpProp->Value.lpszA || IsBadStringPtrA(lpProp->Value.lpszA, -1))
1292             return TRUE;
1293         break;
1294     case PT_UNICODE:
1295         if (!lpProp->Value.lpszW || IsBadStringPtrW(lpProp->Value.lpszW, -1))
1296             return TRUE;
1297         break;
1298     case PT_BINARY:
1299         if (IsBadReadPtr(lpProp->Value.bin.lpb, lpProp->Value.bin.cb))
1300             return TRUE;
1301         break;
1302     case PT_CLSID:
1303         if (IsBadReadPtr(lpProp->Value.lpguid, sizeof(GUID)))
1304             return TRUE;
1305         break;
1306
1307     /* Multiple value properties (arrays) containing no pointers */
1308     case PT_MV_I2:
1309         return PROP_BadArray(lpProp, sizeof(SHORT));
1310     case PT_MV_LONG:
1311         return PROP_BadArray(lpProp, sizeof(LONG));
1312     case PT_MV_LONGLONG:
1313         return PROP_BadArray(lpProp, sizeof(LONG64));
1314     case PT_MV_FLOAT:
1315         return PROP_BadArray(lpProp, sizeof(float));
1316     case PT_MV_SYSTIME:
1317         return PROP_BadArray(lpProp, sizeof(FILETIME));
1318     case PT_MV_APPTIME:
1319     case PT_MV_DOUBLE:
1320         return PROP_BadArray(lpProp, sizeof(double));
1321     case PT_MV_CURRENCY:
1322         return PROP_BadArray(lpProp, sizeof(CY));
1323     case PT_MV_CLSID:
1324         return PROP_BadArray(lpProp, sizeof(GUID));
1325
1326     /* Multiple value properties containing pointers */
1327     case PT_MV_STRING8:
1328         return FBadRglpszA(lpProp->Value.MVszA.lppszA,
1329                            lpProp->Value.MVszA.cValues);
1330     case PT_MV_UNICODE:
1331         return FBadRglpszW(lpProp->Value.MVszW.lppszW,
1332                            lpProp->Value.MVszW.cValues);
1333     case PT_MV_BINARY:
1334         return FBadEntryList(&lpProp->Value.MVbin);
1335     }
1336     return FALSE;
1337 }
1338
1339 /*************************************************************************
1340  * FBadColumnSet@4 (MAPI32.182)
1341  *
1342  * Determine if an array of property tags is invalid
1343  *
1344  * PARAMS
1345  *  lpCols [I] Property tag array to check
1346  *
1347  * RETURNS
1348  *  TRUE, if lpCols is invalid, FALSE otherwise.
1349  */
1350 ULONG WINAPI FBadColumnSet(LPSPropTagArray lpCols)
1351 {
1352     ULONG ulRet = FALSE, i;
1353
1354     TRACE("(%p)\n", lpCols);
1355
1356     if (!lpCols || IsBadReadPtr(lpCols, CbSPropTagArray(lpCols)))
1357         ulRet = TRUE;
1358     else
1359     {
1360         for (i = 0; i < lpCols->cValues; i++)
1361         {
1362             if ((lpCols->aulPropTag[i] & PROP_TYPE_MASK) == PT_ERROR ||
1363                 FBadPropTag(lpCols->aulPropTag[i]))
1364             {
1365                 ulRet = TRUE;
1366                 break;
1367             }
1368         }
1369     }
1370     TRACE("Returning %s\n", ulRet ? "TRUE" : "FALSE");
1371     return ulRet;
1372 }
1373
1374
1375 /**************************************************************************
1376  *  IMAPIProp {MAPI32}
1377  *
1378  * The default Mapi interface for manipulating object properties.
1379  *
1380  * DESCRIPTION
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.
1384  *
1385  * METHODS
1386  */
1387
1388 /* A single property in a property data collection */
1389 typedef struct
1390 {
1391   struct list  entry;
1392   ULONG        ulAccess; /* The property value access level */
1393   LPSPropValue value;    /* The property value */
1394 } IPropDataItem, *LPIPropDataItem;
1395
1396  /* The main property data collection structure */
1397 typedef struct
1398 {
1399     const 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 */
1408 } IPropDataImpl;
1409
1410 /* Internal - Get a property value, assumes lock is held */
1411 static IPropDataItem *IMAPIPROP_GetValue(IPropDataImpl *This, ULONG ulPropTag)
1412 {
1413     struct list *cursor;
1414
1415     LIST_FOR_EACH(cursor, &This->values)
1416     {
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))
1420             return current;
1421     }
1422     return NULL;
1423 }
1424
1425 /* Internal - Add a new property value, assumes lock is held */
1426 static IPropDataItem *IMAPIPROP_AddValue(IPropDataImpl *This,
1427                                          LPSPropValue lpProp)
1428 {
1429     LPVOID lpMem;
1430     LPIPropDataItem lpNew;
1431     HRESULT hRet;
1432
1433     hRet = This->lpAlloc(sizeof(IPropDataItem), &lpMem);
1434
1435     if (SUCCEEDED(hRet))
1436     {
1437         lpNew = lpMem;
1438         lpNew->ulAccess = IPROP_READWRITE;
1439
1440         /* Allocate the value separately so we can update it easily */
1441         lpMem = NULL;
1442         hRet = This->lpAlloc(sizeof(SPropValue), &lpMem);
1443         if (SUCCEEDED(hRet))
1444         {
1445             lpNew->value = lpMem;
1446
1447             hRet = PropCopyMore(lpNew->value, lpProp, This->lpMore, lpMem);
1448             if (SUCCEEDED(hRet))
1449             {
1450                 list_add_tail(&This->values, &lpNew->entry);
1451                 This->ulNumValues++;
1452                 return lpNew;
1453             }
1454             This->lpFree(lpNew->value);
1455         }
1456         This->lpFree(lpNew);
1457     }
1458     return NULL;
1459 }
1460
1461 /* Internal - Lock an IPropData object */
1462 static inline void IMAPIPROP_Lock(IPropDataImpl *This)
1463 {
1464     EnterCriticalSection(&This->cs);
1465 }
1466
1467 /* Internal - Unlock an IPropData object */
1468 static inline void IMAPIPROP_Unlock(IPropDataImpl *This)
1469 {
1470     LeaveCriticalSection(&This->cs);
1471 }
1472
1473 /* This one seems to be missing from mapidefs.h */
1474 #define CbNewSPropProblemArray(c) \
1475     (offsetof(SPropProblemArray,aProblem)+(c)*sizeof(SPropProblem))
1476
1477 /**************************************************************************
1478  *  IMAPIProp_QueryInterface {MAPI32}
1479  *
1480  * Inherited method from the IUnknown Interface.
1481  * See IUnknown_QueryInterface.
1482  *
1483  * NOTES
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.
1487  */
1488 static inline HRESULT IMAPIProp_fnQueryInterface(LPMAPIPROP iface, REFIID riid, LPVOID *ppvObj)
1489 {
1490     IPropDataImpl *This = (IPropDataImpl*)iface;
1491
1492     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj);
1493
1494     if (!ppvObj || !riid)
1495         return MAPI_E_INVALID_PARAMETER;
1496
1497     *ppvObj = NULL;
1498
1499     if(IsEqualIID(riid, &IID_IUnknown) ||
1500        IsEqualIID(riid, &IID_IMAPIProp) ||
1501        IsEqualIID(riid, &IID_IMAPIPropData))
1502     {
1503         *ppvObj = This;
1504         IPropData_AddRef(iface);
1505         TRACE("returning %p\n", *ppvObj);
1506         return S_OK;
1507     }
1508
1509     TRACE("returning E_NOINTERFACE\n");
1510     return MAPI_E_INTERFACE_NOT_SUPPORTED;
1511 }
1512
1513 /**************************************************************************
1514  *  IMAPIProp_AddRef {MAPI32}
1515  *
1516  * Inherited method from the IUnknown Interface.
1517  * See IUnknown_AddRef.
1518  */
1519 static inline ULONG IMAPIProp_fnAddRef(LPMAPIPROP iface)
1520 {
1521     IPropDataImpl *This = (IPropDataImpl*)iface;
1522
1523     TRACE("(%p)->(count before=%u)\n", This, This->lRef);
1524
1525     return InterlockedIncrement(&This->lRef);
1526 }
1527
1528 /**************************************************************************
1529  *  IMAPIProp_Release {MAPI32}
1530  *
1531  * Inherited method from the IUnknown Interface.
1532  * See IUnknown_Release.
1533  */
1534 static inline ULONG IMAPIProp_fnRelease(LPMAPIPROP iface)
1535 {
1536     IPropDataImpl *This = (IPropDataImpl*)iface;
1537     LONG lRef;
1538
1539     TRACE("(%p)->(count before=%u)\n", This, This->lRef);
1540
1541     lRef = InterlockedDecrement(&This->lRef);
1542     if (!lRef)
1543     {
1544         TRACE("Destroying IPropData (%p)\n",This);
1545
1546         /* Note: No need to lock, since no other thread is referencing iface */
1547         while (!list_empty(&This->values))
1548         {
1549             struct list *head = list_head(&This->values);
1550             LPIPropDataItem current = LIST_ENTRY(head, IPropDataItem, entry);
1551             list_remove(head);
1552             This->lpFree(current->value);
1553             This->lpFree(current);
1554         }
1555         This->cs.DebugInfo->Spare[0] = 0;
1556         DeleteCriticalSection(&This->cs);
1557         This->lpFree(This);
1558     }
1559     return (ULONG)lRef;
1560 }
1561
1562 /**************************************************************************
1563  *  IMAPIProp_GetLastError {MAPI32}
1564  *
1565  * Get information about the last error that occurred in an IMAPIProp object.
1566  *
1567  * PARAMS
1568  *  iface    [I] IMAPIProp object that experienced the error
1569  *  hRes     [I] Result of the call that returned an error
1570  *  ulFlags  [I] 0=return Ascii strings, MAPI_UNICODE=return Unicode strings
1571  *  lppError [O] Destination for detailed error information
1572  *
1573  * RETURNS
1574  *  Success: S_OK. *lppError contains details about the last error.
1575  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid,
1576  *           MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
1577  *
1578  * NOTES
1579  *  - If this function succeeds, the returned information in *lppError must be
1580  *  freed using MAPIFreeBuffer() once the caller is finished with it.
1581  *  - It is possible for this function to succeed and set *lppError to NULL,
1582  *  if there is no further information to report about hRes.
1583  */
1584 static inline HRESULT
1585 IMAPIProp_fnGetLastError(LPMAPIPROP iface, HRESULT hRes,
1586                          ULONG ulFlags, LPMAPIERROR *lppError)
1587 {
1588     TRACE("(%p,0x%08X,0x%08X,%p)\n", iface, hRes, ulFlags, lppError);
1589
1590     if (!lppError  || SUCCEEDED(hRes) || (ulFlags & ~MAPI_UNICODE))
1591         return MAPI_E_INVALID_PARAMETER;
1592
1593     *lppError = NULL;
1594     return S_OK;
1595 }
1596
1597 /**************************************************************************
1598  *  IMAPIProp_SaveChanges {MAPI32}
1599  *
1600  * Update any changes made to a transactional IMAPIProp object.
1601  *
1602  * PARAMS
1603  *  iface    [I] IMAPIProp object to update
1604  *  ulFlags  [I] Flags controlling the update.
1605  *
1606  * RETURNS
1607  *  Success: S_OK. Any outstanding changes are committed to the object.
1608  *  Failure: An HRESULT error code describing the error.
1609  */
1610 static inline HRESULT
1611 IMAPIProp_fnSaveChanges(LPMAPIPROP iface, ULONG ulFlags)
1612 {
1613     TRACE("(%p,0x%08X)\n", iface, ulFlags);
1614
1615      /* Since this object is not transacted we do not need to implement this */
1616      /* FIXME: Should we set the access levels to clean? */
1617     return S_OK;
1618 }
1619
1620 /**************************************************************************
1621  *  IMAPIProp_GetProps {MAPI32}
1622  *
1623  * Get property values from an IMAPIProp object.
1624  *
1625  * PARAMS
1626  *  iface    [I] IMAPIProp object to get the property values from
1627  *  lpTags   [I] Property tage of property values to be retrieved
1628  *  ulFlags  [I] Return 0=Ascii MAPI_UNICODE=Unicode strings for
1629  *                 unspecified types
1630  *  lpCount  [O] Destination for number of properties returned
1631  *  lppProps [O] Destination for returned property values
1632  *
1633  * RETURNS
1634  *  Success: S_OK. *lppProps and *lpCount are updated.
1635  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1636  *           MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
1637  *           MAPI_W_ERRORS_RETURNED if not all properties were retrieved
1638  *           successfully.
1639  * NOTES
1640  *  - If MAPI_W_ERRORS_RETURNED is returned, any properties that could not be
1641  *    retrieved from iface are present in lppProps with their type
1642  *    changed to PT_ERROR and Id unchanged.
1643  */
1644 static inline HRESULT
1645 IMAPIProp_fnGetProps(LPMAPIPROP iface, LPSPropTagArray lpTags,
1646                      ULONG ulFlags, ULONG *lpCount, LPSPropValue *lppProps)
1647 {
1648     ULONG i;
1649     HRESULT hRet = S_OK;
1650     IPropDataImpl *This = (IPropDataImpl*)iface;
1651
1652     TRACE("(%p,%p,0x%08x,%p,%p) stub\n", iface, lpTags, ulFlags,
1653           lpCount, lppProps);
1654
1655     if (!iface || ulFlags & ~MAPI_UNICODE || !lpTags || *lpCount || !lppProps)
1656         return MAPI_E_INVALID_PARAMETER;
1657
1658     FIXME("semi-stub, flags not supported\n");
1659
1660     *lpCount = lpTags->cValues;
1661     *lppProps = NULL;
1662
1663     if (*lpCount)
1664     {
1665         hRet = MAPIAllocateBuffer(*lpCount * sizeof(SPropValue), (LPVOID*)lppProps);
1666         if (FAILED(hRet))
1667             return hRet;
1668
1669         IMAPIPROP_Lock(This);
1670
1671         for (i = 0; i < lpTags->cValues; i++)
1672         {
1673             HRESULT hRetTmp = E_INVALIDARG;
1674             LPIPropDataItem item;
1675
1676             item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
1677
1678             if (item)
1679                 hRetTmp = PropCopyMore(&(*lppProps)[i], item->value,
1680                                        This->lpMore, *lppProps);
1681             if (FAILED(hRetTmp))
1682             {
1683                 hRet = MAPI_W_ERRORS_RETURNED;
1684                 (*lppProps)[i].ulPropTag =
1685                     CHANGE_PROP_TYPE(lpTags->aulPropTag[i], PT_ERROR);
1686             }
1687         }
1688
1689         IMAPIPROP_Unlock(This);
1690     }
1691     return hRet;
1692 }
1693
1694 /**************************************************************************
1695  *  MAPIProp_GetPropList {MAPI32}
1696  *
1697  * Get the list of property tags for all values in an IMAPIProp object.
1698  *
1699  * PARAMS
1700  *  iface   [I] IMAPIProp object to get the property tag list from
1701  *  ulFlags [I] Return 0=Ascii MAPI_UNICODE=Unicode strings for
1702  *              unspecified types
1703  *  lppTags [O] Destination for the retrieved property tag list
1704  *
1705  * RETURNS
1706  *  Success: S_OK. *lppTags contains the tags for all available properties.
1707  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1708  *           MAPI_E_BAD_CHARWIDTH, if Ascii or Unicode strings are requested
1709  *           and that type of string is not supported.
1710  */
1711 static inline HRESULT
1712 IMAPIProp_fnGetPropList(LPMAPIPROP iface, ULONG ulFlags,
1713                         LPSPropTagArray *lppTags)
1714 {
1715     IPropDataImpl *This = (IPropDataImpl*)iface;
1716     ULONG i;
1717     HRESULT hRet;
1718
1719     TRACE("(%p,0x%08x,%p) stub\n", iface, ulFlags, lppTags);
1720
1721     if (!iface || ulFlags & ~MAPI_UNICODE || !lppTags)
1722         return MAPI_E_INVALID_PARAMETER;
1723
1724     FIXME("semi-stub, flags not supported\n");
1725
1726     *lppTags = NULL;
1727
1728     IMAPIPROP_Lock(This);
1729
1730     hRet = MAPIAllocateBuffer(CbNewSPropTagArray(This->ulNumValues),
1731                               (LPVOID*)lppTags);
1732     if (SUCCEEDED(hRet))
1733     {
1734         struct list *cursor;
1735
1736         i = 0;
1737         LIST_FOR_EACH(cursor, &This->values)
1738         {
1739             LPIPropDataItem current = LIST_ENTRY(cursor, IPropDataItem, entry);
1740             (*lppTags)->aulPropTag[i] = current->value->ulPropTag;
1741             i++;
1742         }
1743         (*lppTags)->cValues = This->ulNumValues;
1744     }
1745
1746     IMAPIPROP_Unlock(This);
1747     return hRet;
1748 }
1749
1750 /**************************************************************************
1751  *  IMAPIProp_OpenProperty {MAPI32}
1752  *
1753  * Not documented at this time.
1754  *
1755  * RETURNS
1756  *  An HRESULT success/failure code.
1757  */
1758 static inline HRESULT
1759 IMAPIProp_fnOpenProperty(LPMAPIPROP iface, ULONG ulPropTag, LPCIID iid,
1760                          ULONG ulOpts, ULONG ulFlags, LPUNKNOWN *lpUnk)
1761 {
1762     FIXME("(%p,%u,%s,%u,0x%08x,%p) stub\n", iface, ulPropTag,
1763           debugstr_guid(iid), ulOpts, ulFlags, lpUnk);
1764     return MAPI_E_NO_SUPPORT;
1765 }
1766
1767
1768 /**************************************************************************
1769  *  IMAPIProp_SetProps {MAPI32}
1770  *
1771  * Add or edit the property values in an IMAPIProp object.
1772  *
1773  * PARAMS
1774  *  iface    [I] IMAPIProp object to get the property tag list from
1775  *  ulValues [I] Number of properties in lpProps
1776  *  lpProps  [I] Property values to set
1777  *  lppProbs [O] Optional destination for any problems that occurred
1778  *
1779  * RETURNS
1780  *  Success: S_OK. The properties in lpProps are added to iface if they don't
1781  *           exist, or changed to the values in lpProps if they do
1782  *  Failure: An HRESULT error code describing the error
1783  */
1784 static inline HRESULT
1785 IMAPIProp_fnSetProps(LPMAPIPROP iface, ULONG ulValues,
1786                      LPSPropValue lpProps, LPSPropProblemArray *lppProbs)
1787 {
1788     IPropDataImpl *This = (IPropDataImpl*)iface;
1789     HRESULT hRet = S_OK;
1790     ULONG i;
1791
1792     TRACE("(%p,%u,%p,%p)\n", iface, ulValues, lpProps, lppProbs);
1793
1794     if (!iface || !lpProps)
1795       return MAPI_E_INVALID_PARAMETER;
1796
1797     for (i = 0; i < ulValues; i++)
1798     {
1799         if (FBadProp(&lpProps[i]) ||
1800             PROP_TYPE(lpProps[i].ulPropTag) == PT_OBJECT ||
1801             PROP_TYPE(lpProps[i].ulPropTag) == PT_NULL)
1802           return MAPI_E_INVALID_PARAMETER;
1803     }
1804
1805     IMAPIPROP_Lock(This);
1806
1807     /* FIXME: Under what circumstances is lpProbs created? */
1808     for (i = 0; i < ulValues; i++)
1809     {
1810         LPIPropDataItem item = IMAPIPROP_GetValue(This, lpProps[i].ulPropTag);
1811
1812         if (item)
1813         {
1814             HRESULT hRetTmp;
1815             LPVOID lpMem = NULL;
1816
1817             /* Found, so update the existing value */
1818             if (item->value->ulPropTag != lpProps[i].ulPropTag)
1819                 FIXME("semi-stub, overwriting type (not coercing)\n");
1820
1821             hRetTmp = This->lpAlloc(sizeof(SPropValue), &lpMem);
1822             if (SUCCEEDED(hRetTmp))
1823             {
1824                 hRetTmp = PropCopyMore(lpMem, &lpProps[i], This->lpMore, lpMem);
1825                 if (SUCCEEDED(hRetTmp))
1826                 {
1827                     This->lpFree(item->value);
1828                     item->value = lpMem;
1829                     continue;
1830                 }
1831                 This->lpFree(lpMem);
1832             }
1833             hRet = hRetTmp;
1834         }
1835         else
1836         {
1837             /* Add new value */
1838             if (!(item = IMAPIPROP_AddValue(This, &lpProps[i])))
1839                 hRet = MAPI_E_NOT_ENOUGH_MEMORY;
1840         }
1841     }
1842
1843     IMAPIPROP_Unlock(This);
1844     return hRet;
1845 }
1846
1847 /**************************************************************************
1848  *  IMAPIProp_DeleteProps {MAPI32}
1849  *
1850  * Delete one or more property values from an IMAPIProp object.
1851  *
1852  * PARAMS
1853  *  iface    [I] IMAPIProp object to remove property values from.
1854  *  lpTags   [I] Collection of property Id's to remove from iface.
1855  *  lppProbs [O] Destination for problems encountered, if any.
1856  *
1857  * RETURNS
1858  *  Success: S_OK. Any properties in iface matching property Id's in lpTags have
1859  *           been deleted. If lppProbs is non-NULL it contains details of any
1860  *           errors that occurred.
1861  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
1862  *           E_ACCESSDENIED, if this object was created using CreateIProp() and
1863  *           a subsequent call to IPropData_SetObjAcess() was made specifying
1864  *           IPROP_READONLY as the access type.
1865  *
1866  * NOTES
1867  *  - lppProbs will not be populated for cases where a property Id is present
1868  *    in lpTags but not in iface.
1869  *  - lppProbs should be deleted with MAPIFreeBuffer() if returned.
1870  */
1871 static inline HRESULT
1872 IMAPIProp_fnDeleteProps(LPMAPIPROP iface, LPSPropTagArray lpTags,
1873                         LPSPropProblemArray *lppProbs)
1874 {
1875     IPropDataImpl *This = (IPropDataImpl*)iface;
1876     ULONG i, numProbs = 0;
1877     HRESULT hRet = S_OK;
1878
1879     TRACE("(%p,%p,%p)\n", iface, lpTags, lppProbs);
1880
1881     if (!iface || !lpTags)
1882         return MAPI_E_INVALID_PARAMETER;
1883
1884     if (lppProbs)
1885         *lppProbs = NULL;
1886
1887     for (i = 0; i < lpTags->cValues; i++)
1888     {
1889         if (FBadPropTag(lpTags->aulPropTag[i]) ||
1890             PROP_TYPE(lpTags->aulPropTag[i]) == PT_OBJECT ||
1891             PROP_TYPE(lpTags->aulPropTag[i]) == PT_NULL)
1892           return MAPI_E_INVALID_PARAMETER;
1893     }
1894
1895     IMAPIPROP_Lock(This);
1896
1897     if (This->ulObjAccess != IPROP_READWRITE)
1898     {
1899         IMAPIPROP_Unlock(This);
1900         return E_ACCESSDENIED;
1901     }
1902
1903     for (i = 0; i < lpTags->cValues; i++)
1904     {
1905         LPIPropDataItem item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
1906
1907         if (item)
1908         {
1909             if (item->ulAccess & IPROP_READWRITE)
1910             {
1911                 /* Everything hunky-dory, remove the item */
1912                 list_remove(&item->entry);
1913                 This->lpFree(item->value); /* Also frees value pointers */
1914                 This->lpFree(item);
1915                 This->ulNumValues--;
1916             }
1917             else if (lppProbs)
1918             {
1919                  /* Can't write the value. Create/populate problems array */
1920                  if (!*lppProbs)
1921                  {
1922                      /* Create problems array */
1923                      ULONG ulSize = CbNewSPropProblemArray(lpTags->cValues - i);
1924                      HRESULT hRetTmp = MAPIAllocateBuffer(ulSize, (LPVOID*)lppProbs);
1925                      if (FAILED(hRetTmp))
1926                          hRet = hRetTmp;
1927                  }
1928                  if (*lppProbs)
1929                  {
1930                      LPSPropProblem lpProb = &(*lppProbs)->aProblem[numProbs];
1931                      lpProb->ulIndex = i;
1932                      lpProb->ulPropTag = lpTags->aulPropTag[i];
1933                      lpProb->scode = E_ACCESSDENIED;
1934                      numProbs++;
1935                  }
1936             }
1937         }
1938     }
1939     if (lppProbs && *lppProbs)
1940         (*lppProbs)->cProblem = numProbs;
1941
1942     IMAPIPROP_Unlock(This);
1943     return hRet;
1944 }
1945
1946
1947 /**************************************************************************
1948  *  IMAPIProp_CopyTo {MAPI32}
1949  *
1950  * Not documented at this time.
1951  *
1952  * RETURNS
1953  *  An HRESULT success/failure code.
1954  */
1955 static inline HRESULT
1956 IMAPIProp_fnCopyTo(LPMAPIPROP iface, ULONG niids, LPCIID lpiidExcl,
1957                    LPSPropTagArray lpPropsExcl, ULONG ulParam,
1958                    LPMAPIPROGRESS lpIProgress, LPCIID lpIfaceIid, LPVOID lpDstObj,
1959                    ULONG ulFlags, LPSPropProblemArray *lppProbs)
1960 {
1961     FIXME("(%p,%u,%p,%p,%x,%p,%s,%p,0x%08X,%p) stub\n", iface, niids,
1962           lpiidExcl, lpPropsExcl, ulParam, lpIProgress,
1963           debugstr_guid(lpIfaceIid), lpDstObj, ulFlags, lppProbs);
1964     return MAPI_E_NO_SUPPORT;
1965 }
1966
1967 /**************************************************************************
1968  *  IMAPIProp_CopyProps {MAPI32}
1969  *
1970  * Not documented at this time.
1971  *
1972  * RETURNS
1973  *  An HRESULT success/failure code.
1974  */
1975 static inline HRESULT
1976 IMAPIProp_fnCopyProps(LPMAPIPROP iface, LPSPropTagArray lpInclProps,
1977                       ULONG ulParam, LPMAPIPROGRESS lpIProgress, LPCIID lpIface,
1978                       LPVOID lpDstObj, ULONG ulFlags,
1979                       LPSPropProblemArray *lppProbs)
1980 {
1981     FIXME("(%p,%p,%x,%p,%s,%p,0x%08X,%p) stub\n", iface, lpInclProps,
1982           ulParam, lpIProgress, debugstr_guid(lpIface), lpDstObj, ulFlags,
1983           lppProbs);
1984     return MAPI_E_NO_SUPPORT;
1985 }
1986
1987 /**************************************************************************
1988  *  IMAPIProp_GetNamesFromIDs {MAPI32}
1989  *
1990  * Get the names of properties from their identifiers.
1991  *
1992  * PARAMS
1993  *  iface       [I]   IMAPIProp object to operate on
1994  *  lppPropTags [I/O] Property identifiers to get the names for, or NULL to
1995  *                    get all names
1996  *  iid         [I]   Property set identifier, or NULL
1997  *  ulFlags     [I]   MAPI_NO_IDS=Don't return numeric named properties,
1998  *                    or MAPI_NO_STRINGS=Don't return strings
1999  *  lpCount     [O]   Destination for number of properties returned
2000  *  lpppNames   [O]   Destination for returned names
2001  *
2002  * RETURNS
2003  *  Success: S_OK. *lppPropTags and lpppNames contain the returned
2004  *           name/identifiers.
2005  *  Failure: MAPI_E_NO_SUPPORT, if the object does not support named properties,
2006  *           MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
2007  *           MAPI_W_ERRORS_RETURNED if not all properties were retrieved
2008  *           successfully.
2009  */
2010 static inline HRESULT
2011 IMAPIProp_fnGetNamesFromIDs(LPMAPIPROP iface, LPSPropTagArray *lppPropTags,
2012                             LPGUID iid, ULONG ulFlags, ULONG *lpCount,
2013                             LPMAPINAMEID **lpppNames)
2014 {
2015     FIXME("(%p,%p,%s,0x%08X,%p,%p) stub\n", iface, lppPropTags,
2016           debugstr_guid(iid), ulFlags, lpCount, lpppNames);
2017     return MAPI_E_NO_SUPPORT;
2018 }
2019
2020 /**************************************************************************
2021  *  IMAPIProp_GetIDsFromNames {MAPI32}
2022  *
2023  * Get property identifiers associated with one or more named properties.
2024  *
2025  * PARAMS
2026  *  iface       [I] IMAPIProp object to operate on
2027  *  ulNames     [I] Number of names in lppNames
2028  *  lppNames    [I] Names to query or create, or NULL to query all names
2029  *  ulFlags     [I] Pass MAPI_CREATE to create new named properties
2030  *  lppPropTags [O] Destination for queried or created property identifiers
2031  *
2032  * RETURNS
2033  *  Success: S_OK. *lppPropTags contains the property tags created or requested.
2034  *  Failure: MAPI_E_NO_SUPPORT, if the object does not support named properties,
2035  *           MAPI_E_TOO_BIG, if the object cannot process the number of
2036  *           properties involved.
2037  *           MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails, or
2038  *           MAPI_W_ERRORS_RETURNED if not all properties were retrieved
2039  *           successfully.
2040  */
2041 static inline HRESULT
2042 IMAPIProp_fnGetIDsFromNames(LPMAPIPROP iface, ULONG ulNames,
2043                             LPMAPINAMEID *lppNames, ULONG ulFlags,
2044                             LPSPropTagArray *lppPropTags)
2045 {
2046     FIXME("(%p,%d,%p,0x%08X,%p) stub\n",
2047           iface, ulNames, lppNames, ulFlags, lppPropTags);
2048     return MAPI_E_NO_SUPPORT;
2049 }
2050
2051 /**************************************************************************
2052  *  IPropData {MAPI32}
2053  *
2054  * A default Mapi interface to provide manipulation of object properties.
2055  *
2056  * DESCRIPTION
2057  *  This object provides a default interface suitable in some cases as an
2058  *  implementation of the IMAPIProp interface (which has no default
2059  *  implementation). In addition to the IMAPIProp() methods inherited, this
2060  *  interface allows read/write control over access to the object and its
2061  *  individual properties.
2062  *
2063  *  To obtain the default implementation of this interface from Mapi, call
2064  *  CreateIProp().
2065  *
2066  * METHODS
2067  */
2068
2069 /**************************************************************************
2070  *  IPropData_QueryInterface {MAPI32}
2071  *
2072  * Inherited method from the IMAPIProp Interface.
2073  * See IMAPIProp_QueryInterface.
2074  */
2075 static HRESULT WINAPI
2076 IPropData_fnQueryInterface(LPPROPDATA iface, REFIID riid, LPVOID *ppvObj)
2077 {
2078     return IMAPIProp_fnQueryInterface((LPMAPIPROP)iface, riid, ppvObj);
2079 }
2080
2081 /**************************************************************************
2082  *  IPropData_AddRef {MAPI32}
2083  *
2084  * Inherited method from the IMAPIProp Interface.
2085  * See IMAPIProp_AddRef.
2086  */
2087 static ULONG WINAPI
2088 IPropData_fnAddRef(LPPROPDATA iface)
2089 {
2090     return IMAPIProp_fnAddRef((LPMAPIPROP)iface);
2091 }
2092
2093 /**************************************************************************
2094  *  IPropData_Release {MAPI32}
2095  *
2096  * Inherited method from the IMAPIProp Interface.
2097  * See IMAPIProp_Release.
2098  */
2099 static ULONG WINAPI
2100 IPropData_fnRelease(LPPROPDATA iface)
2101 {
2102     return IMAPIProp_fnRelease((LPMAPIPROP)iface);
2103 }
2104
2105 /**************************************************************************
2106  *  IPropData_GetLastError {MAPI32}
2107  *
2108  * Inherited method from the IMAPIProp Interface.
2109  * See IMAPIProp_GetLastError.
2110  */
2111 static HRESULT WINAPI
2112 IPropData_fnGetLastError(LPPROPDATA iface, HRESULT hRes, ULONG ulFlags,
2113                          LPMAPIERROR *lppError)
2114 {
2115     return IMAPIProp_fnGetLastError((LPMAPIPROP)iface, hRes, ulFlags, lppError);
2116 }
2117
2118 /**************************************************************************
2119  *  IPropData_SaveChanges {MAPI32}
2120  *
2121  * Inherited method from the IMAPIProp Interface.
2122  * See IMAPIProp_SaveChanges.
2123  */
2124 static HRESULT WINAPI
2125 IPropData_fnSaveChanges(LPPROPDATA iface, ULONG ulFlags)
2126 {
2127     return IMAPIProp_fnSaveChanges((LPMAPIPROP)iface, ulFlags);
2128 }
2129
2130 /**************************************************************************
2131  *  IPropData_GetProps {MAPI32}
2132  *
2133  * Inherited method from the IMAPIProp Interface.
2134  * See IMAPIProp_GetProps.
2135  */
2136 static HRESULT WINAPI
2137 IPropData_fnGetProps(LPPROPDATA iface, LPSPropTagArray lpPropTags,
2138                      ULONG ulFlags, ULONG *lpCount, LPSPropValue *lppProps)
2139 {
2140     return IMAPIProp_fnGetProps((LPMAPIPROP)iface, lpPropTags, ulFlags,
2141                                 lpCount, lppProps);
2142 }
2143
2144 /**************************************************************************
2145  *  IPropData_GetPropList {MAPI32}
2146  *
2147  * Inherited method from the IMAPIProp Interface.
2148  * See IMAPIProp_GetPropList.
2149  */
2150 static HRESULT WINAPI
2151 IPropData_fnGetPropList(LPPROPDATA iface, ULONG ulFlags,
2152                                               LPSPropTagArray *lppPropTags)
2153 {
2154     return IMAPIProp_fnGetPropList((LPMAPIPROP)iface, ulFlags, lppPropTags);
2155 }
2156
2157 /**************************************************************************
2158  *  IPropData_OpenProperty {MAPI32}
2159  *
2160  * Inherited method from the IMAPIProp Interface.
2161  * See IMAPIProp_OpenProperty.
2162  */
2163 static HRESULT WINAPI
2164 IPropData_fnOpenProperty(LPPROPDATA iface, ULONG ulPropTag, LPCIID iid,
2165                          ULONG ulOpts, ULONG ulFlags, LPUNKNOWN *lpUnk)
2166 {
2167     return IMAPIProp_fnOpenProperty((LPMAPIPROP)iface, ulPropTag, iid,
2168                                     ulOpts, ulFlags, lpUnk);
2169 }
2170
2171 /**************************************************************************
2172  *  IPropData_SetProps {MAPI32}
2173  *
2174  * Inherited method from the IMAPIProp Interface.
2175  * See IMAPIProp_SetProps.
2176  */
2177 static HRESULT WINAPI
2178 IPropData_fnSetProps(LPPROPDATA iface, ULONG cValues, LPSPropValue lpProps,
2179                      LPSPropProblemArray *lppProbs)
2180 {
2181     return IMAPIProp_fnSetProps((LPMAPIPROP)iface, cValues, lpProps, lppProbs);
2182 }
2183
2184 /**************************************************************************
2185  *  IPropData_DeleteProps {MAPI32}
2186  *
2187  * Inherited method from the IMAPIProp Interface.
2188  * See IMAPIProp_DeleteProps.
2189  */
2190 static HRESULT WINAPI
2191 IPropData_fnDeleteProps(LPPROPDATA iface, LPSPropTagArray lpPropTags,
2192                         LPSPropProblemArray *lppProbs)
2193 {
2194     return IMAPIProp_fnDeleteProps((LPMAPIPROP)iface, lpPropTags, lppProbs);
2195 }
2196
2197 /**************************************************************************
2198  *  IPropData_CopyTo {MAPI32}
2199  *
2200  * Inherited method from the IMAPIProp Interface.
2201  * See IMAPIProp_CopyTo.
2202  */
2203 static HRESULT WINAPI
2204 IPropData_fnCopyTo(LPPROPDATA iface, ULONG ciidExclude, LPCIID lpIid,
2205                    LPSPropTagArray lpProps, ULONG ulParam,
2206                    LPMAPIPROGRESS lpProgress, LPCIID lpIface, LPVOID lpDst,
2207                    ULONG ulFlags, LPSPropProblemArray *lppProbs)
2208 {
2209     return IMAPIProp_fnCopyTo((LPMAPIPROP)iface, ciidExclude, lpIid, lpProps,
2210                               ulParam, lpProgress, lpIface, lpDst,
2211                               ulFlags, lppProbs);
2212 }
2213
2214 /**************************************************************************
2215  *  IPropData_CopyProps {MAPI32}
2216  *
2217  * Inherited method from the IMAPIProp Interface.
2218  * See IMAPIProp_CopyProps.
2219  */
2220 static HRESULT WINAPI
2221 IPropData_fnCopyProps(LPPROPDATA iface, LPSPropTagArray lpProps,
2222                       ULONG ulParam, LPMAPIPROGRESS lpProgress, LPCIID lpIface,
2223                       LPVOID lpDst, ULONG ulFlags, LPSPropProblemArray *lppProbs)
2224 {
2225     return IMAPIProp_fnCopyProps((LPMAPIPROP)iface, lpProps, ulParam,
2226                                  lpProgress, lpIface, lpDst, ulFlags, lppProbs);
2227 }
2228
2229 /**************************************************************************
2230  *  IPropData_GetNamesFromIDs {MAPI32}
2231  *
2232  * Inherited method from the IMAPIProp Interface.
2233  * See IMAPIProp_GetNamesFromIDs.
2234  */
2235 static HRESULT WINAPI
2236 IPropData_fnGetNamesFromIDs(LPPROPDATA iface, LPSPropTagArray *lppPropTags,
2237                             LPGUID iid, ULONG ulFlags, ULONG *lpCount,
2238                             LPMAPINAMEID **lpppNames)
2239 {
2240     return IMAPIProp_fnGetNamesFromIDs((LPMAPIPROP)iface, lppPropTags, iid,
2241                                        ulFlags, lpCount, lpppNames);
2242 }
2243
2244 /**************************************************************************
2245  *  IPropData_GetIDsFromNames {MAPI32}
2246  *
2247  * Inherited method from the IMAPIProp Interface.
2248  * See IMAPIProp_GetIDsFromNames.
2249  */
2250 static HRESULT WINAPI
2251 IPropData_fnGetIDsFromNames(LPPROPDATA iface, ULONG ulNames,
2252                             LPMAPINAMEID *lppNames, ULONG ulFlags,
2253                             LPSPropTagArray *lppPropTags)
2254 {
2255     return IMAPIProp_fnGetIDsFromNames((LPMAPIPROP)iface, ulNames, lppNames,
2256                                        ulFlags, lppPropTags);
2257 }
2258
2259 /**************************************************************************
2260  *  IPropData_HrSetObjAccess {MAPI32}
2261  *
2262  * Set the access level of an IPropData object.
2263  *
2264  * PARAMS
2265  *  iface    [I] IPropData object to set the access on
2266  *  ulAccess [I] Either IPROP_READONLY or IPROP_READWRITE for read or
2267  *               read/write access respectively.
2268  *
2269  * RETURNS
2270  *  Success: S_OK. The objects access level is changed.
2271  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
2272  */
2273 static HRESULT WINAPI
2274 IPropData_fnHrSetObjAccess(LPPROPDATA iface, ULONG ulAccess)
2275 {
2276     IPropDataImpl *This = (IPropDataImpl*)iface;
2277
2278     TRACE("(%p,%x)\n", iface, ulAccess);
2279
2280     if (!iface || ulAccess < IPROP_READONLY || ulAccess > IPROP_READWRITE)
2281         return MAPI_E_INVALID_PARAMETER;
2282
2283     IMAPIPROP_Lock(This);
2284
2285     This->ulObjAccess = ulAccess;
2286
2287     IMAPIPROP_Unlock(This);
2288     return S_OK;
2289 }
2290
2291 /* Internal - determine if an access value is bad */
2292 static inline BOOL PROP_IsBadAccess(ULONG ulAccess)
2293 {
2294     switch (ulAccess)
2295     {
2296     case IPROP_READONLY|IPROP_CLEAN:
2297     case IPROP_READONLY|IPROP_DIRTY:
2298     case IPROP_READWRITE|IPROP_CLEAN:
2299     case IPROP_READWRITE|IPROP_DIRTY:
2300         return FALSE;
2301     }
2302     return TRUE;
2303 }
2304
2305 /**************************************************************************
2306  *  IPropData_HrSetPropAccess {MAPI32}
2307  *
2308  * Set the access levels for a group of property values in an IPropData object.
2309  *
2310  * PARAMS
2311  *  iface    [I] IPropData object to set access levels in.
2312  *  lpTags   [I] List of property Id's to set access for.
2313  *  lpAccess [O] Access level for each property in lpTags.
2314  *
2315  * RETURNS
2316  *  Success: S_OK. The access level of each property value in lpTags that is
2317  *           present in iface is changed.
2318  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid.
2319  *
2320  * NOTES
2321  *  - Each access level in lpAccess must contain at least one of IPROP_READONLY
2322  *    or IPROP_READWRITE, but not both, and also IPROP_CLEAN or IPROP_DIRTY,
2323  *    but not both. No other bits should be set.
2324  *  - If a property Id in lpTags is not present in iface, it is ignored.
2325  */
2326 static HRESULT WINAPI
2327 IPropData_fnHrSetPropAccess(LPPROPDATA iface, LPSPropTagArray lpTags,
2328                             ULONG *lpAccess)
2329 {
2330     IPropDataImpl *This = (IPropDataImpl*)iface;
2331
2332     ULONG i;
2333
2334     TRACE("(%p,%p,%p)\n", iface, lpTags, lpAccess);
2335
2336     if (!iface || !lpTags || !lpAccess)
2337         return MAPI_E_INVALID_PARAMETER;
2338
2339     for (i = 0; i < lpTags->cValues; i++)
2340     {
2341         if (FBadPropTag(lpTags->aulPropTag[i]) || PROP_IsBadAccess(lpAccess[i]))
2342             return MAPI_E_INVALID_PARAMETER;
2343     }
2344
2345     IMAPIPROP_Lock(This);
2346
2347     for (i = 0; i < lpTags->cValues; i++)
2348     {
2349         LPIPropDataItem item = IMAPIPROP_GetValue(This, lpTags->aulPropTag[i]);
2350
2351         if (item)
2352             item->ulAccess = lpAccess[i];
2353     }
2354
2355     IMAPIPROP_Unlock(This);
2356     return S_OK;
2357 }
2358
2359 /**************************************************************************
2360  *  IPropData_HrGetPropAccess {MAPI32}
2361  *
2362  * Get the access levels for a group of property values in an IPropData object.
2363  *
2364  * PARAMS
2365  *  iface     [I] IPropData object to get access levels from.
2366  *  lppTags   [O] Destination for the list of property Id's in iface.
2367  *  lppAccess [O] Destination for access level for each property in lppTags.
2368  *
2369  * RETURNS
2370  *  Success: S_OK. lppTags and lppAccess contain the property Id's and the
2371  *           Access level of each property value in iface.
2372  *  Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid, or
2373  *           MAPI_E_NOT_ENOUGH_MEMORY if memory allocation fails.
2374  *
2375  * NOTES
2376  *  - *lppTags and *lppAccess should be freed with MAPIFreeBuffer() by the caller.
2377  */
2378 static HRESULT WINAPI
2379 IPropData_fnHrGetPropAccess(LPPROPDATA iface, LPSPropTagArray *lppTags,
2380                             ULONG **lppAccess)
2381 {
2382     IPropDataImpl *This = (IPropDataImpl*)iface;
2383     LPVOID lpMem;
2384     HRESULT hRet;
2385     ULONG i;
2386
2387     TRACE("(%p,%p,%p) stub\n", iface, lppTags, lppAccess);
2388
2389     if (!iface || !lppTags || !lppAccess)
2390         return MAPI_E_INVALID_PARAMETER;
2391
2392     *lppTags = NULL;
2393     *lppAccess = NULL;
2394
2395     IMAPIPROP_Lock(This);
2396
2397     hRet = This->lpAlloc(CbNewSPropTagArray(This->ulNumValues), &lpMem);
2398     if (SUCCEEDED(hRet))
2399     {
2400         *lppTags = lpMem;
2401
2402         hRet = This->lpAlloc(This->ulNumValues * sizeof(ULONG), &lpMem);
2403         if (SUCCEEDED(hRet))
2404         {
2405             struct list *cursor;
2406
2407             *lppAccess = lpMem;
2408             (*lppTags)->cValues = This->ulNumValues;
2409
2410             i = 0;
2411             LIST_FOR_EACH(cursor, &This->values)
2412             {
2413                 LPIPropDataItem item = LIST_ENTRY(cursor, IPropDataItem, entry);
2414                 (*lppTags)->aulPropTag[i] = item->value->ulPropTag;
2415                 (*lppAccess)[i] = item->ulAccess;
2416                 i++;
2417             }
2418             IMAPIPROP_Unlock(This);
2419             return S_OK;
2420         }
2421         This->lpFree(*lppTags);
2422         *lppTags = 0;
2423     }
2424     IMAPIPROP_Unlock(This);
2425     return MAPI_E_NOT_ENOUGH_MEMORY;
2426 }
2427
2428 /**************************************************************************
2429  *  IPropData_HrAddObjProps {MAPI32}
2430  *
2431  * Not documented at this time.
2432  *
2433  * RETURNS
2434  *  An HRESULT success/failure code.
2435  */
2436 static HRESULT WINAPI
2437 IPropData_fnHrAddObjProps(LPPROPDATA iface, LPSPropTagArray lpTags,
2438                           LPSPropProblemArray *lppProbs)
2439 {
2440 #if 0
2441     ULONG i;
2442     HRESULT hRet;
2443     LPSPropValue lpValues;
2444 #endif
2445
2446     FIXME("(%p,%p,%p) stub\n", iface, lpTags, lppProbs);
2447
2448     if (!iface || !lpTags)
2449         return MAPI_E_INVALID_PARAMETER;
2450
2451     /* FIXME: Below is the obvious implementation, adding all the properties
2452      *        in lpTags to the object. However, it doesn't appear that this
2453      *        is what this function does.
2454      */
2455     return S_OK;
2456 #if 0
2457     if (!lpTags->cValues)
2458         return S_OK;
2459
2460     lpValues = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2461                          lpTags->cValues * sizeof(SPropValue));
2462     if (!lpValues)
2463         return MAPI_E_NOT_ENOUGH_MEMORY;
2464
2465     for (i = 0; i < lpTags->cValues; i++)
2466         lpValues[i].ulPropTag = lpTags->aulPropTag[i];
2467
2468     hRet = IPropData_SetProps(iface, lpTags->cValues, lpValues, lppProbs);
2469     HeapFree(GetProcessHeap(), 0, lpValues);
2470     return hRet;
2471 #endif
2472 }
2473
2474 static const IPropDataVtbl IPropDataImpl_vtbl =
2475 {
2476     IPropData_fnQueryInterface,
2477     IPropData_fnAddRef,
2478     IPropData_fnRelease,
2479     IPropData_fnGetLastError,
2480     IPropData_fnSaveChanges,
2481     IPropData_fnGetProps,
2482     IPropData_fnGetPropList,
2483     IPropData_fnOpenProperty,
2484     IPropData_fnSetProps,
2485     IPropData_fnDeleteProps,
2486     IPropData_fnCopyTo,
2487     IPropData_fnCopyProps,
2488     IPropData_fnGetNamesFromIDs,
2489     IPropData_fnGetIDsFromNames,
2490     IPropData_fnHrSetObjAccess,
2491     IPropData_fnHrSetPropAccess,
2492     IPropData_fnHrGetPropAccess,
2493     IPropData_fnHrAddObjProps
2494 };
2495
2496 /*************************************************************************
2497  * CreateIProp@24 (MAPI32.60)
2498  *
2499  * Create an IPropData object.
2500  *
2501  * PARAMS
2502  *  iid         [I] GUID of the object to create. Use &IID_IMAPIPropData or NULL
2503  *  lpAlloc     [I] Memory allocation function. Use MAPIAllocateBuffer()
2504  *  lpMore      [I] Linked memory allocation function. Use MAPIAllocateMore()
2505  *  lpFree      [I] Memory free function. Use MAPIFreeBuffer()
2506  *  lpReserved  [I] Reserved, set to NULL
2507  *  lppPropData [O] Destination for created IPropData object
2508  *
2509  * RETURNS
2510  *  Success: S_OK. *lppPropData contains the newly created object.
2511  *  Failure: MAPI_E_INTERFACE_NOT_SUPPORTED, if iid is non-NULL and not supported,
2512  *           MAPI_E_INVALID_PARAMETER, if any parameter is invalid
2513  */
2514 SCODE WINAPI CreateIProp(LPCIID iid, ALLOCATEBUFFER *lpAlloc,
2515                          ALLOCATEMORE *lpMore, FREEBUFFER *lpFree,
2516                          LPVOID lpReserved, LPPROPDATA *lppPropData)
2517 {
2518     IPropDataImpl *lpPropData;
2519     SCODE scode;
2520
2521     TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_guid(iid), lpAlloc, lpMore, lpFree,
2522           lpReserved, lppPropData);
2523
2524     if (lppPropData)
2525         *lppPropData = NULL;
2526
2527     if (iid && !IsEqualGUID(iid, &IID_IMAPIPropData))
2528         return MAPI_E_INTERFACE_NOT_SUPPORTED;
2529
2530     if (!lpAlloc || !lpMore || !lpFree || lpReserved || !lppPropData)
2531         return MAPI_E_INVALID_PARAMETER;
2532
2533     scode = lpAlloc(sizeof(IPropDataImpl), (LPVOID*)&lpPropData);
2534
2535     if (SUCCEEDED(scode))
2536     {
2537         lpPropData->lpVtbl = &IPropDataImpl_vtbl;
2538         lpPropData->lRef = 1;
2539         lpPropData->lpAlloc = lpAlloc;
2540         lpPropData->lpMore = lpMore;
2541         lpPropData->lpFree = lpFree;
2542         lpPropData->ulObjAccess = IPROP_READWRITE;
2543         lpPropData->ulNumValues = 0;
2544         list_init(&lpPropData->values);
2545         InitializeCriticalSection(&lpPropData->cs);
2546         lpPropData->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IPropDataImpl.cs");
2547         *lppPropData = (LPPROPDATA)lpPropData;
2548     }
2549     return scode;
2550 }