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