| /* |
| * Property functions |
| * |
| * Copyright 2004 Jon Griffiths |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <stdarg.h> |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winreg.h" |
| #include "winerror.h" |
| #include "winternl.h" |
| #include "objbase.h" |
| #include "shlwapi.h" |
| #include "wine/debug.h" |
| #include "wine/unicode.h" |
| #include "mapival.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(mapi); |
| |
| BOOL WINAPI FBadRglpszA(LPSTR*,ULONG); |
| BOOL WINAPI FBadRglpszW(LPWSTR*,ULONG); |
| |
| /* Internal: Check if a property value array is invalid */ |
| static inline ULONG PROP_BadArray(LPSPropValue lpProp, size_t elemSize) |
| { |
| return IsBadReadPtr(lpProp->Value.MVi.lpi, lpProp->Value.MVi.cValues * elemSize); |
| } |
| |
| /************************************************************************* |
| * PropCopyMore@16 (MAPI32.76) |
| * |
| * Copy a property value. |
| * |
| * PARAMS |
| * lpDest [O] Destination for the copied value |
| * lpSrc [I] Property value to copy to lpDest |
| * lpMore [I] Linked memory allocation function (pass MAPIAllocateMore()) |
| * lpOrig [I] Original allocation to which memory will be linked |
| * |
| * RETURNS |
| * Success: S_OK. lpDest contains a deep copy of lpSrc. |
| * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid, |
| * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails. |
| * |
| * NOTES |
| * Any elements within the property returned should not be individually |
| * freed, as they will be freed when lpOrig is. |
| */ |
| SCODE WINAPI PropCopyMore(LPSPropValue lpDest, LPSPropValue lpSrc, |
| ALLOCATEMORE *lpMore, LPVOID lpOrig) |
| { |
| ULONG ulLen, i; |
| SCODE scode = S_OK; |
| |
| TRACE("(%p,%p,%p,%p)\n", lpDest, lpSrc, lpMore, lpOrig); |
| |
| if (!lpDest || IsBadWritePtr(lpDest, sizeof(SPropValue)) || |
| FBadProp(lpSrc) || !lpMore) |
| return MAPI_E_INVALID_PARAMETER; |
| |
| /* Shallow copy first, this is sufficient for properties without pointers */ |
| *lpDest = *lpSrc; |
| |
| switch (PROP_TYPE(lpSrc->ulPropTag)) |
| { |
| case PT_CLSID: |
| scode = lpMore(sizeof(GUID), lpOrig, (LPVOID*)&lpDest->Value.lpguid); |
| if (SUCCEEDED(scode)) |
| memcpy(lpDest->Value.lpguid, lpSrc->Value.lpguid, sizeof(GUID)); |
| break; |
| case PT_STRING8: |
| ulLen = lstrlenA(lpSrc->Value.lpszA) + 1u; |
| scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszA); |
| if (SUCCEEDED(scode)) |
| memcpy(lpDest->Value.lpszA, lpSrc->Value.lpszA, ulLen); |
| break; |
| case PT_UNICODE: |
| ulLen = (strlenW(lpSrc->Value.lpszW) + 1u) * sizeof(WCHAR); |
| scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.lpszW); |
| if (SUCCEEDED(scode)) |
| memcpy(lpDest->Value.lpszW, lpSrc->Value.lpszW, ulLen); |
| break; |
| case PT_BINARY: |
| scode = lpMore(lpSrc->Value.bin.cb, lpOrig, (LPVOID*)&lpDest->Value.bin.lpb); |
| if (SUCCEEDED(scode)) |
| memcpy(lpDest->Value.bin.lpb, lpSrc->Value.bin.lpb, lpSrc->Value.bin.cb); |
| break; |
| default: |
| if (lpSrc->ulPropTag & MV_FLAG) |
| { |
| ulLen = UlPropSize(lpSrc); |
| |
| if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_STRING8 || |
| PROP_TYPE(lpSrc->ulPropTag) == PT_MV_UNICODE) |
| { |
| /* UlPropSize doesn't account for the string pointers */ |
| ulLen += lpSrc->Value.MVszA.cValues * sizeof(char*); |
| } |
| else if (PROP_TYPE(lpSrc->ulPropTag) == PT_MV_BINARY) |
| { |
| /* UlPropSize doesn't account for the SBinary structs */ |
| ulLen += lpSrc->Value.MVbin.cValues * sizeof(SBinary); |
| } |
| |
| lpDest->Value.MVi.cValues = lpSrc->Value.MVi.cValues; |
| scode = lpMore(ulLen, lpOrig, (LPVOID*)&lpDest->Value.MVi.lpi); |
| if (FAILED(scode)) |
| break; |
| |
| /* Note that we could allocate the memory for each value in a |
| * multi-value property seperately, however if an allocation failed |
| * we would be left with a bunch of allocated memory, which (while |
| * not really leaked) is unusable until lpOrig is freed. So for |
| * strings and binary arrays we make a single allocation for all |
| * of the data. This is consistent since individual elements can't |
| * be freed anyway. |
| */ |
| |
| switch (PROP_TYPE(lpSrc->ulPropTag)) |
| { |
| case PT_MV_STRING8: |
| { |
| char *lpNextStr = (char*)(lpDest->Value.MVszA.lppszA + |
| lpDest->Value.MVszA.cValues); |
| |
| for (i = 0; i < lpSrc->Value.MVszA.cValues; i++) |
| { |
| ULONG ulStrLen = lstrlenA(lpSrc->Value.MVszA.lppszA[i]) + 1u; |
| |
| lpDest->Value.MVszA.lppszA[i] = lpNextStr; |
| memcpy(lpNextStr, lpSrc->Value.MVszA.lppszA[i], ulStrLen); |
| lpNextStr += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_UNICODE: |
| { |
| WCHAR *lpNextStr = (WCHAR*)(lpDest->Value.MVszW.lppszW + |
| lpDest->Value.MVszW.cValues); |
| |
| for (i = 0; i < lpSrc->Value.MVszW.cValues; i++) |
| { |
| ULONG ulStrLen = strlenW(lpSrc->Value.MVszW.lppszW[i]) + 1u; |
| |
| lpDest->Value.MVszW.lppszW[i] = lpNextStr; |
| memcpy(lpNextStr, lpSrc->Value.MVszW.lppszW[i], ulStrLen * sizeof(WCHAR)); |
| lpNextStr += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_BINARY: |
| { |
| LPBYTE lpNext = (LPBYTE)(lpDest->Value.MVbin.lpbin + |
| lpDest->Value.MVbin.cValues); |
| |
| for (i = 0; i < lpSrc->Value.MVszW.cValues; i++) |
| { |
| lpDest->Value.MVbin.lpbin[i].cb = lpSrc->Value.MVbin.lpbin[i].cb; |
| lpDest->Value.MVbin.lpbin[i].lpb = lpNext; |
| memcpy(lpNext, lpSrc->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb); |
| lpNext += lpDest->Value.MVbin.lpbin[i].cb; |
| } |
| break; |
| } |
| default: |
| /* No embedded pointers, just copy the data over */ |
| memcpy(lpDest->Value.MVi.lpi, lpSrc->Value.MVi.lpi, ulLen); |
| break; |
| } |
| break; |
| } |
| } |
| return scode; |
| } |
| |
| /************************************************************************* |
| * UlPropSize@4 (MAPI32.77) |
| * |
| * Determine the size of a property in bytes. |
| * |
| * PARAMS |
| * lpProp [I] Property to determine the size of |
| * |
| * RETURNS |
| * Success: The size of the value in lpProp. |
| * Failure: 0, if a multi-value (array) property is invalid or the type of lpProp |
| * is unknown. |
| * |
| * NOTES |
| * - The size returned does not include the size of the SPropValue struct |
| * or the size of the array of pointers for multi-valued properties that |
| * contain pointers (such as PT_MV_STRING8 or PT-MV_UNICODE). |
| * - MSDN incorrectly states that this function returns MAPI_E_CALL_FAILED if |
| * lpProp is invalid. In reality no checking is performed and this function |
| * will crash if passed an invalid property, or return 0 if the property |
| * type is PT_OBJECT or is unknown. |
| */ |
| ULONG WINAPI UlPropSize(LPSPropValue lpProp) |
| { |
| ULONG ulRet = 1u, i; |
| |
| TRACE("(%p)\n", lpProp); |
| |
| switch (PROP_TYPE(lpProp->ulPropTag)) |
| { |
| case PT_MV_I2: ulRet = lpProp->Value.MVi.cValues; |
| case PT_BOOLEAN: |
| case PT_I2: ulRet *= sizeof(USHORT); |
| break; |
| case PT_MV_I4: ulRet = lpProp->Value.MVl.cValues; |
| case PT_ERROR: |
| case PT_I4: ulRet *= sizeof(LONG); |
| break; |
| case PT_MV_I8: ulRet = lpProp->Value.MVli.cValues; |
| case PT_I8: ulRet *= sizeof(LONG64); |
| break; |
| case PT_MV_R4: ulRet = lpProp->Value.MVflt.cValues; |
| case PT_R4: ulRet *= sizeof(float); |
| break; |
| case PT_MV_APPTIME: |
| case PT_MV_R8: ulRet = lpProp->Value.MVdbl.cValues; |
| case PT_APPTIME: |
| case PT_R8: ulRet *= sizeof(double); |
| break; |
| case PT_MV_CURRENCY: ulRet = lpProp->Value.MVcur.cValues; |
| case PT_CURRENCY: ulRet *= sizeof(CY); |
| break; |
| case PT_MV_SYSTIME: ulRet = lpProp->Value.MVft.cValues; |
| case PT_SYSTIME: ulRet *= sizeof(FILETIME); |
| break; |
| case PT_MV_CLSID: ulRet = lpProp->Value.MVguid.cValues; |
| case PT_CLSID: ulRet *= sizeof(GUID); |
| break; |
| case PT_MV_STRING8: ulRet = 0u; |
| for (i = 0; i < lpProp->Value.MVszA.cValues; i++) |
| ulRet += (lstrlenA(lpProp->Value.MVszA.lppszA[i]) + 1u); |
| break; |
| case PT_STRING8: ulRet = lstrlenA(lpProp->Value.lpszA) + 1u; |
| break; |
| case PT_MV_UNICODE: ulRet = 0u; |
| for (i = 0; i < lpProp->Value.MVszW.cValues; i++) |
| ulRet += (strlenW(lpProp->Value.MVszW.lppszW[i]) + 1u); |
| ulRet *= sizeof(WCHAR); |
| break; |
| case PT_UNICODE: ulRet = (lstrlenW(lpProp->Value.lpszW) + 1u) * sizeof(WCHAR); |
| break; |
| case PT_MV_BINARY: ulRet = 0u; |
| for (i = 0; i < lpProp->Value.MVbin.cValues; i++) |
| ulRet += lpProp->Value.MVbin.lpbin[i].cb; |
| break; |
| case PT_BINARY: ulRet = lpProp->Value.bin.cb; |
| break; |
| break; |
| case PT_OBJECT: |
| default: ulRet = 0u; |
| break; |
| } |
| |
| return ulRet; |
| } |
| |
| /************************************************************************* |
| * FPropContainsProp@12 (MAPI32.78) |
| * |
| * Find a property with a given property tag in a property array. |
| * |
| * PARAMS |
| * lpHaystack [I] Property to match to |
| * lpNeedle [I] Property to find in lpHaystack |
| * ulFuzzy [I] Flags controlling match type and strictness (FL_* flags from "mapidefs.h") |
| * |
| * RETURNS |
| * TRUE, if lpNeedle matches lpHaystack according to the criteria of ulFuzzy. |
| * |
| * NOTES |
| * Only property types of PT_STRING8 and PT_BINARY are handled by this function. |
| */ |
| BOOL WINAPI FPropContainsProp(LPSPropValue lpHaystack, LPSPropValue lpNeedle, ULONG ulFuzzy) |
| { |
| TRACE("(%p,%p,0x%08lx)\n", lpHaystack, lpNeedle, ulFuzzy); |
| |
| if (FBadProp(lpHaystack) || FBadProp(lpNeedle) || |
| PROP_TYPE(lpHaystack->ulPropTag) != PROP_TYPE(lpNeedle->ulPropTag)) |
| return FALSE; |
| |
| /* FIXME: Do later versions support Unicode as well? */ |
| |
| if (PROP_TYPE(lpHaystack->ulPropTag) == PT_STRING8) |
| { |
| DWORD dwFlags = 0, dwNeedleLen, dwHaystackLen; |
| |
| if (ulFuzzy & FL_IGNORECASE) |
| dwFlags |= NORM_IGNORECASE; |
| if (ulFuzzy & FL_IGNORENONSPACE) |
| dwFlags |= NORM_IGNORENONSPACE; |
| if (ulFuzzy & FL_LOOSE) |
| dwFlags |= (NORM_IGNORECASE|NORM_IGNORENONSPACE|NORM_IGNORESYMBOLS); |
| |
| dwNeedleLen = lstrlenA(lpNeedle->Value.lpszA); |
| dwHaystackLen = lstrlenA(lpHaystack->Value.lpszA); |
| |
| if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX) |
| { |
| if (dwNeedleLen <= dwHaystackLen && |
| CompareStringA(LOCALE_USER_DEFAULT, dwFlags, |
| lpHaystack->Value.lpszA, dwNeedleLen, |
| lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL) |
| return TRUE; /* needle is a prefix of haystack */ |
| } |
| else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING) |
| { |
| LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD) = StrChrA; |
| LPSTR lpStr = lpHaystack->Value.lpszA; |
| |
| if (dwFlags & NORM_IGNORECASE) |
| pStrChrFn = StrChrIA; |
| |
| while ((lpStr = pStrChrFn(lpStr, *lpNeedle->Value.lpszA)) != NULL) |
| { |
| dwHaystackLen -= (lpStr - lpHaystack->Value.lpszA); |
| if (dwNeedleLen <= dwHaystackLen && |
| CompareStringA(LOCALE_USER_DEFAULT, dwFlags, |
| lpStr, dwNeedleLen, |
| lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL) |
| return TRUE; /* needle is a substring of haystack */ |
| lpStr++; |
| } |
| } |
| else if (CompareStringA(LOCALE_USER_DEFAULT, dwFlags, |
| lpHaystack->Value.lpszA, dwHaystackLen, |
| lpNeedle->Value.lpszA, dwNeedleLen) == CSTR_EQUAL) |
| return TRUE; /* full string match */ |
| } |
| else if (PROP_TYPE(lpHaystack->ulPropTag) == PT_BINARY) |
| { |
| if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_PREFIX) |
| { |
| if (lpNeedle->Value.bin.cb <= lpHaystack->Value.bin.cb && |
| !memcmp(lpNeedle->Value.bin.lpb, lpHaystack->Value.bin.lpb, |
| lpNeedle->Value.bin.cb)) |
| return TRUE; /* needle is a prefix of haystack */ |
| } |
| else if ((ulFuzzy & (FL_SUBSTRING|FL_PREFIX)) == FL_SUBSTRING) |
| { |
| ULONG ulLen = lpHaystack->Value.bin.cb; |
| LPBYTE lpb = lpHaystack->Value.bin.lpb; |
| |
| while ((lpb = memchr(lpb, *lpNeedle->Value.bin.lpb, ulLen)) != NULL) |
| { |
| ulLen = lpHaystack->Value.bin.cb - (lpb - lpHaystack->Value.bin.lpb); |
| if (lpNeedle->Value.bin.cb <= ulLen && |
| !memcmp(lpNeedle->Value.bin.lpb, lpb, lpNeedle->Value.bin.cb)) |
| return TRUE; /* needle is a substring of haystack */ |
| lpb++; |
| } |
| } |
| else if (!LPropCompareProp(lpHaystack, lpNeedle)) |
| return TRUE; /* needle is an exact match with haystack */ |
| |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FPropCompareProp@12 (MAPI32.79) |
| * |
| * Compare two properties. |
| * |
| * PARAMS |
| * lpPropLeft [I] Left hand property to compare to lpPropRight |
| * ulOp [I] Comparison operator (RELOP_* enum from "mapidefs.h") |
| * lpPropRight [I] Right hand property to compare to lpPropLeft |
| * |
| * RETURNS |
| * TRUE, if the comparison is true, FALSE otherwise. |
| */ |
| BOOL WINAPI FPropCompareProp(LPSPropValue lpPropLeft, ULONG ulOp, LPSPropValue lpPropRight) |
| { |
| LONG iCmp; |
| |
| TRACE("(%p,%ld,%p)\n", lpPropLeft, ulOp, lpPropRight); |
| |
| if (ulOp > RELOP_RE || FBadProp(lpPropLeft) || FBadProp(lpPropRight)) |
| return FALSE; |
| |
| if (ulOp == RELOP_RE) |
| { |
| FIXME("Comparison operator RELOP_RE not yet implemented!\n"); |
| return FALSE; |
| } |
| |
| iCmp = LPropCompareProp(lpPropLeft, lpPropRight); |
| |
| switch (ulOp) |
| { |
| case RELOP_LT: return iCmp < 0 ? TRUE : FALSE; |
| case RELOP_LE: return iCmp <= 0 ? TRUE : FALSE; |
| case RELOP_GT: return iCmp > 0 ? TRUE : FALSE; |
| case RELOP_GE: return iCmp >= 0 ? TRUE : FALSE; |
| case RELOP_EQ: return iCmp == 0 ? TRUE : FALSE; |
| case RELOP_NE: return iCmp != 0 ? TRUE : FALSE; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * LPropCompareProp@8 (MAPI32.80) |
| * |
| * Compare two properties. |
| * |
| * PARAMS |
| * lpPropLeft [I] Left hand property to compare to lpPropRight |
| * lpPropRight [I] Right hand property to compare to lpPropLeft |
| * |
| * RETURNS |
| * An integer less than, equal to or greater than 0, indicating that |
| * lpszStr is less than, the same, or greater than lpszComp. |
| */ |
| LONG WINAPI LPropCompareProp(LPSPropValue lpPropLeft, LPSPropValue lpPropRight) |
| { |
| LONG iRet; |
| |
| TRACE("(%p->0x%08lx,%p->0x%08lx)\n", lpPropLeft, lpPropLeft->ulPropTag, |
| lpPropRight, lpPropRight->ulPropTag); |
| |
| /* If the properties are not the same, sort by property type */ |
| if (PROP_TYPE(lpPropLeft->ulPropTag) != PROP_TYPE(lpPropRight->ulPropTag)) |
| return (LONG)PROP_TYPE(lpPropLeft->ulPropTag) - (LONG)PROP_TYPE(lpPropRight->ulPropTag); |
| |
| switch (PROP_TYPE(lpPropLeft->ulPropTag)) |
| { |
| case PT_UNSPECIFIED: |
| case PT_NULL: |
| return 0; /* NULLs are equal */ |
| case PT_I2: |
| return lpPropLeft->Value.i - lpPropRight->Value.i; |
| case PT_I4: |
| return lpPropLeft->Value.l - lpPropRight->Value.l; |
| case PT_I8: |
| if (lpPropLeft->Value.li.QuadPart > lpPropRight->Value.li.QuadPart) |
| return 1; |
| if (lpPropLeft->Value.li.QuadPart == lpPropRight->Value.li.QuadPart) |
| return 0; |
| return -1; |
| case PT_R4: |
| if (lpPropLeft->Value.flt > lpPropRight->Value.flt) |
| return 1; |
| if (lpPropLeft->Value.flt == lpPropRight->Value.flt) |
| return 0; |
| return -1; |
| case PT_APPTIME: |
| case PT_R8: |
| if (lpPropLeft->Value.dbl > lpPropRight->Value.dbl) |
| return 1; |
| if (lpPropLeft->Value.dbl == lpPropRight->Value.dbl) |
| return 0; |
| return -1; |
| case PT_CURRENCY: |
| if (lpPropLeft->Value.cur.int64 > lpPropRight->Value.cur.int64) |
| return 1; |
| if (lpPropLeft->Value.cur.int64 == lpPropRight->Value.cur.int64) |
| return 0; |
| return -1; |
| case PT_SYSTIME: |
| return CompareFileTime(&lpPropLeft->Value.ft, &lpPropRight->Value.ft); |
| case PT_BOOLEAN: |
| return (lpPropLeft->Value.b ? 1 : 0) - (lpPropRight->Value.b ? 1 : 0); |
| case PT_BINARY: |
| if (lpPropLeft->Value.bin.cb == lpPropRight->Value.bin.cb) |
| iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb, |
| lpPropLeft->Value.bin.cb); |
| else |
| { |
| iRet = memcmp(lpPropLeft->Value.bin.lpb, lpPropRight->Value.bin.lpb, |
| min(lpPropLeft->Value.bin.cb, lpPropRight->Value.bin.cb)); |
| |
| if (!iRet) |
| iRet = lpPropLeft->Value.bin.cb - lpPropRight->Value.bin.cb; |
| } |
| return iRet; |
| case PT_STRING8: |
| return lstrcmpA(lpPropLeft->Value.lpszA, lpPropRight->Value.lpszA); |
| case PT_UNICODE: |
| return strcmpW(lpPropLeft->Value.lpszW, lpPropRight->Value.lpszW); |
| case PT_ERROR: |
| if (lpPropLeft->Value.err > lpPropRight->Value.err) |
| return 1; |
| if (lpPropLeft->Value.err == lpPropRight->Value.err) |
| return 0; |
| return -1; |
| case PT_CLSID: |
| return memcmp(lpPropLeft->Value.lpguid, lpPropRight->Value.lpguid, |
| sizeof(GUID)); |
| } |
| FIXME("Unhandled property type %ld", PROP_TYPE(lpPropLeft->ulPropTag)); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * HrGetOneProp@8 (MAPI32.135) |
| * |
| * Get a property value from an IMAPIProp object. |
| * |
| * PARAMS |
| * lpIProp [I] IMAPIProp object to get the property value in |
| * ulPropTag [I] Property tag of the property to get |
| * lppProp [O] Destination for the returned property |
| * |
| * RETURNS |
| * Success: S_OK. *lppProp contains the property value requested. |
| * Failure: MAPI_E_NOT_FOUND, if no property value has the tag given by ulPropTag. |
| */ |
| HRESULT WINAPI HrGetOneProp(LPMAPIPROP lpIProp, ULONG ulPropTag, LPSPropValue *lppProp) |
| { |
| SPropTagArray pta; |
| ULONG ulCount; |
| HRESULT hRet; |
| |
| TRACE("(%p,%ld,%p)\n", lpIProp, ulPropTag, lppProp); |
| |
| pta.cValues = 1u; |
| pta.aulPropTag[0] = ulPropTag; |
| hRet = IMAPIProp_GetProps(lpIProp, &pta, 0u, &ulCount, lppProp); |
| if (hRet == MAPI_W_ERRORS_RETURNED) |
| { |
| MAPIFreeBuffer(*lppProp); |
| *lppProp = NULL; |
| hRet = MAPI_E_NOT_FOUND; |
| } |
| return hRet; |
| } |
| |
| /************************************************************************* |
| * HrSetOneProp@8 (MAPI32.136) |
| * |
| * Set a property value in an IMAPIProp object. |
| * |
| * PARAMS |
| * lpIProp [I] IMAPIProp object to set the property value in |
| * lpProp [I] Property value to set |
| * |
| * RETURNS |
| * Success: S_OK. The value in lpProp is set in lpIProp. |
| * Failure: An error result from IMAPIProp_SetProps(). |
| */ |
| HRESULT WINAPI HrSetOneProp(LPMAPIPROP lpIProp, LPSPropValue lpProp) |
| { |
| TRACE("(%p,%p)\n", lpIProp, lpProp); |
| |
| return IMAPIProp_SetProps(lpIProp, 1u, lpProp, NULL); |
| } |
| |
| /************************************************************************* |
| * FPropExists@8 (MAPI32.137) |
| * |
| * Find a property with a given property tag in an IMAPIProp object. |
| * |
| * PARAMS |
| * lpIProp [I] IMAPIProp object to find the property tag in |
| * ulPropTag [I] Property tag to find |
| * |
| * RETURNS |
| * TRUE, if ulPropTag matches a property held in lpIProp, |
| * FALSE, otherwise. |
| * |
| * NOTES |
| * if ulPropTag has a property type of PT_UNSPECIFIED, then only the property |
| * Ids need to match for a successful match to occur. |
| */ |
| BOOL WINAPI FPropExists(LPMAPIPROP lpIProp, ULONG ulPropTag) |
| { |
| BOOL bRet = FALSE; |
| |
| TRACE("(%p,%ld)\n", lpIProp, ulPropTag); |
| |
| if (lpIProp) |
| { |
| LPSPropTagArray lpTags; |
| ULONG i; |
| |
| if (FAILED(IMAPIProp_GetPropList(lpIProp, 0u, &lpTags))) |
| return FALSE; |
| |
| for (i = 0; i < lpTags->cValues; i++) |
| { |
| if (!FBadPropTag(lpTags->aulPropTag[i]) && |
| (lpTags->aulPropTag[i] == ulPropTag || |
| (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED && |
| PROP_ID(lpTags->aulPropTag[i]) == lpTags->aulPropTag[i]))) |
| { |
| bRet = TRUE; |
| break; |
| } |
| } |
| MAPIFreeBuffer(lpTags); |
| } |
| return bRet; |
| } |
| |
| /************************************************************************* |
| * PpropFindProp@12 (MAPI32.138) |
| * |
| * Find a property with a given property tag in a property array. |
| * |
| * PARAMS |
| * lpProps [I] Property array to search |
| * cValues [I] Number of properties in lpProps |
| * ulPropTag [I] Property tag to find |
| * |
| * RETURNS |
| * A pointer to the matching property, or NULL if none was found. |
| * |
| * NOTES |
| * if ulPropTag has a property type of PT_UNSPECIFIED, then only the property |
| * Ids need to match for a successful match to occur. |
| */ |
| LPSPropValue WINAPI PpropFindProp(LPSPropValue lpProps, ULONG cValues, ULONG ulPropTag) |
| { |
| TRACE("(%p,%ld,%ld)\n", lpProps, cValues, ulPropTag); |
| |
| if (lpProps && cValues) |
| { |
| ULONG i; |
| for (i = 0; i < cValues; i++) |
| { |
| if (!FBadPropTag(lpProps[i].ulPropTag) && |
| (lpProps[i].ulPropTag == ulPropTag || |
| (PROP_TYPE(ulPropTag) == PT_UNSPECIFIED && |
| PROP_ID(lpProps[i].ulPropTag) == PROP_ID(ulPropTag)))) |
| return &lpProps[i]; |
| } |
| } |
| return NULL; |
| } |
| |
| /************************************************************************* |
| * FreePadrlist@4 (MAPI32.139) |
| * |
| * Free the memory used by an address book list. |
| * |
| * PARAMS |
| * lpAddrs [I] Address book list to free |
| * |
| * RETURNS |
| * Nothing. |
| */ |
| VOID WINAPI FreePadrlist(LPADRLIST lpAddrs) |
| { |
| TRACE("(%p)\n", lpAddrs); |
| |
| /* Structures are binary compatible; use the same implementation */ |
| return FreeProws((LPSRowSet)lpAddrs); |
| } |
| |
| /************************************************************************* |
| * FreeProws@4 (MAPI32.140) |
| * |
| * Free the memory used by a row set. |
| * |
| * PARAMS |
| * lpRowSet [I] Row set to free |
| * |
| * RETURNS |
| * Nothing. |
| */ |
| VOID WINAPI FreeProws(LPSRowSet lpRowSet) |
| { |
| TRACE("(%p)\n", lpRowSet); |
| |
| if (lpRowSet) |
| { |
| ULONG i; |
| |
| for (i = 0; i < lpRowSet->cRows; i++) |
| MAPIFreeBuffer(lpRowSet->aRow[i].lpProps); |
| |
| MAPIFreeBuffer(lpRowSet); |
| } |
| } |
| |
| /************************************************************************* |
| * ScCountProps@12 (MAPI32.170) |
| * |
| * Validate and determine the length of an array of properties. |
| * |
| * PARAMS |
| * iCount [I] Length of the lpProps array |
| * lpProps [I] Array of properties to validate/size |
| * pcBytes [O] If non-NULL, destination for the size of the property array |
| * |
| * RETURNS |
| * Success: S_OK. If pcBytes is non-NULL, it contains the size of the propery array. |
| * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid or validation |
| * of the property array fails. |
| */ |
| SCODE WINAPI ScCountProps(INT iCount, LPSPropValue lpProps, ULONG *pcBytes) |
| { |
| ULONG i, ulCount = iCount, ulBytes = 0; |
| |
| TRACE("(%d,%p,%p)\n", iCount, lpProps, pcBytes); |
| |
| if (iCount <= 0 || !lpProps || |
| IsBadReadPtr(lpProps, iCount * sizeof(SPropValue))) |
| return MAPI_E_INVALID_PARAMETER; |
| |
| for (i = 0; i < ulCount; i++) |
| { |
| ULONG ulPropSize = 0; |
| |
| if (FBadProp(&lpProps[i]) || lpProps[i].ulPropTag == PROP_ID_NULL || |
| lpProps[i].ulPropTag == PROP_ID_INVALID) |
| return MAPI_E_INVALID_PARAMETER; |
| |
| if (PROP_TYPE(lpProps[i].ulPropTag) != PT_OBJECT) |
| { |
| ulPropSize = UlPropSize(&lpProps[i]); |
| if (!ulPropSize) |
| return MAPI_E_INVALID_PARAMETER; |
| } |
| |
| switch (PROP_TYPE(lpProps[i].ulPropTag)) |
| { |
| case PT_STRING8: |
| case PT_UNICODE: |
| case PT_CLSID: |
| case PT_BINARY: |
| case PT_MV_I2: |
| case PT_MV_I4: |
| case PT_MV_I8: |
| case PT_MV_R4: |
| case PT_MV_R8: |
| case PT_MV_CURRENCY: |
| case PT_MV_SYSTIME: |
| case PT_MV_APPTIME: |
| ulPropSize += sizeof(SPropValue); |
| break; |
| case PT_MV_CLSID: |
| ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue); |
| break; |
| case PT_MV_STRING8: |
| case PT_MV_UNICODE: |
| ulPropSize += lpProps[i].Value.MVszA.cValues * sizeof(char*) + sizeof(SPropValue); |
| break; |
| case PT_MV_BINARY: |
| ulPropSize += lpProps[i].Value.MVbin.cValues * sizeof(SBinary) + sizeof(SPropValue); |
| break; |
| default: |
| ulPropSize = sizeof(SPropValue); |
| break; |
| } |
| ulBytes += ulPropSize; |
| } |
| if (pcBytes) |
| *pcBytes = ulBytes; |
| |
| return S_OK; |
| } |
| |
| /************************************************************************* |
| * ScCopyProps@16 (MAPI32.171) |
| * |
| * Copy an array of property values into a buffer suited for serialisation. |
| * |
| * PARAMS |
| * cValues [I] Number of properties in lpProps |
| * lpProps [I] Property array to copy |
| * lpDst [O] Destination for the serialised data |
| * lpCount [O] If non-NULL, destination for the number of bytes of data written to lpDst |
| * |
| * RETURNS |
| * Success: S_OK. lpDst contains the serialised data from lpProps. |
| * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid. |
| * |
| * NOTES |
| * The resulting property value array is stored in a contigous block starting at lpDst. |
| */ |
| SCODE WINAPI ScCopyProps(int cValues, LPSPropValue lpProps, LPVOID lpDst, ULONG *lpCount) |
| { |
| LPSPropValue lpDest = (LPSPropValue)lpDst; |
| char *lpDataDest = (char *)(lpDest + cValues); |
| ULONG ulLen, i, iter; |
| |
| TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpDst, lpCount); |
| |
| if (!lpProps || cValues < 0 || !lpDest) |
| return MAPI_E_INVALID_PARAMETER; |
| |
| memcpy(lpDst, lpProps, cValues * sizeof(SPropValue)); |
| |
| for (iter = 0; iter < cValues; iter++) |
| { |
| switch (PROP_TYPE(lpProps->ulPropTag)) |
| { |
| case PT_CLSID: |
| lpDest->Value.lpguid = (LPGUID)lpDataDest; |
| memcpy(lpDest->Value.lpguid, lpProps->Value.lpguid, sizeof(GUID)); |
| lpDataDest += sizeof(GUID); |
| break; |
| case PT_STRING8: |
| ulLen = lstrlenA(lpProps->Value.lpszA) + 1u; |
| lpDest->Value.lpszA = lpDataDest; |
| memcpy(lpDest->Value.lpszA, lpProps->Value.lpszA, ulLen); |
| lpDataDest += ulLen; |
| break; |
| case PT_UNICODE: |
| ulLen = (strlenW(lpProps->Value.lpszW) + 1u) * sizeof(WCHAR); |
| lpDest->Value.lpszW = (LPWSTR)lpDataDest; |
| memcpy(lpDest->Value.lpszW, lpProps->Value.lpszW, ulLen); |
| lpDataDest += ulLen; |
| break; |
| case PT_BINARY: |
| lpDest->Value.bin.lpb = (LPBYTE)lpDataDest; |
| memcpy(lpDest->Value.bin.lpb, lpProps->Value.bin.lpb, lpProps->Value.bin.cb); |
| lpDataDest += lpProps->Value.bin.cb; |
| break; |
| default: |
| if (lpProps->ulPropTag & MV_FLAG) |
| { |
| lpDest->Value.MVi.cValues = lpProps->Value.MVi.cValues; |
| /* Note: Assignment uses lppszA but covers all cases by union aliasing */ |
| lpDest->Value.MVszA.lppszA = (char**)lpDataDest; |
| |
| switch (PROP_TYPE(lpProps->ulPropTag)) |
| { |
| case PT_MV_STRING8: |
| { |
| lpDataDest += lpProps->Value.MVszA.cValues * sizeof(char *); |
| |
| for (i = 0; i < lpProps->Value.MVszA.cValues; i++) |
| { |
| ULONG ulStrLen = lstrlenA(lpProps->Value.MVszA.lppszA[i]) + 1u; |
| |
| lpDest->Value.MVszA.lppszA[i] = lpDataDest; |
| memcpy(lpDataDest, lpProps->Value.MVszA.lppszA[i], ulStrLen); |
| lpDataDest += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_UNICODE: |
| { |
| lpDataDest += lpProps->Value.MVszW.cValues * sizeof(WCHAR *); |
| |
| for (i = 0; i < lpProps->Value.MVszW.cValues; i++) |
| { |
| ULONG ulStrLen = (strlenW(lpProps->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR); |
| |
| lpDest->Value.MVszW.lppszW[i] = (LPWSTR)lpDataDest; |
| memcpy(lpDataDest, lpProps->Value.MVszW.lppszW[i], ulStrLen); |
| lpDataDest += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_BINARY: |
| { |
| lpDataDest += lpProps->Value.MVszW.cValues * sizeof(SBinary); |
| |
| for (i = 0; i < lpProps->Value.MVszW.cValues; i++) |
| { |
| lpDest->Value.MVbin.lpbin[i].cb = lpProps->Value.MVbin.lpbin[i].cb; |
| lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)lpDataDest; |
| memcpy(lpDataDest, lpProps->Value.MVbin.lpbin[i].lpb, lpDest->Value.MVbin.lpbin[i].cb); |
| lpDataDest += lpDest->Value.MVbin.lpbin[i].cb; |
| } |
| break; |
| } |
| default: |
| /* No embedded pointers, just copy the data over */ |
| ulLen = UlPropSize(lpProps); |
| memcpy(lpDest->Value.MVi.lpi, lpProps->Value.MVi.lpi, ulLen); |
| lpDataDest += ulLen; |
| break; |
| } |
| break; |
| } |
| } |
| lpDest++; |
| lpProps++; |
| } |
| if (lpCount) |
| *lpCount = lpDataDest - (char *)lpDst; |
| |
| return S_OK; |
| } |
| |
| /************************************************************************* |
| * ScRelocProps@20 (MAPI32.172) |
| * |
| * Relocate the pointers in an array of property values after it has been copied. |
| * |
| * PARAMS |
| * cValues [I] Number of properties in lpProps |
| * lpProps [O] Property array to relocate the pointers in. |
| * lpOld [I] Position where the data was copied from |
| * lpNew [I] Position where the data was copied to |
| * lpCount [O] If non-NULL, destination for the number of bytes of data at lpDst |
| * |
| * RETURNS |
| * Success: S_OK. Any pointers in lpProps are relocated. |
| * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid. |
| * |
| * NOTES |
| * MSDN states that this function can be used for serialisation by passing |
| * NULL as either lpOld or lpNew, thus converting any pointers in lpProps |
| * between offsets and pointers. This does not work in native (it crashes), |
| * and cannot be made to work in Wine because the original interface design |
| * is deficient. The only use left for this function is to remap pointers |
| * in a contigous property array that has been copied with memcpy() to another |
| * memory location. |
| */ |
| SCODE WINAPI ScRelocProps(int cValues, LPSPropValue lpProps, LPVOID lpOld, |
| LPVOID lpNew, ULONG *lpCount) |
| { |
| static const BOOL bBadPtr = TRUE; /* Windows bug - Assumes source is bad */ |
| LPSPropValue lpDest = (LPSPropValue)lpProps; |
| ULONG ulCount = cValues * sizeof(SPropValue); |
| ULONG ulLen, i, iter; |
| |
| TRACE("(%d,%p,%p,%p,%p)\n", cValues, lpProps, lpOld, lpNew, lpCount); |
| |
| if (!lpProps || cValues < 0 || !lpOld || !lpNew) |
| return MAPI_E_INVALID_PARAMETER; |
| |
| /* The reason native doesn't work as MSDN states is that it assumes that |
| * the lpProps pointer contains valid pointers. This is obviously not |
| * true if the array is being read back from serialisation (the pointers |
| * are just offsets). Native can't actually work converting the pointers to |
| * offsets either, because it converts any array pointers to offsets then |
| * _dereferences the offset_ in order to convert the array elements! |
| * |
| * The code below would handle both cases except that the design of this |
| * function makes it impossible to know when the pointers in lpProps are |
| * valid. If both lpOld and lpNew are non-NULL, native reads the pointers |
| * after converting them, so we must do the same. Its seems this |
| * functionality was never tested by MS. |
| */ |
| |
| #define RELOC_PTR(p) (((char*)(p)) - (char*)lpOld + (char*)lpNew) |
| |
| for (iter = 0; iter < cValues; iter++) |
| { |
| switch (PROP_TYPE(lpDest->ulPropTag)) |
| { |
| case PT_CLSID: |
| lpDest->Value.lpguid = (LPGUID)RELOC_PTR(lpDest->Value.lpguid); |
| ulCount += sizeof(GUID); |
| break; |
| case PT_STRING8: |
| ulLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.lpszA) + 1u; |
| lpDest->Value.lpszA = (LPSTR)RELOC_PTR(lpDest->Value.lpszA); |
| if (bBadPtr) |
| ulLen = lstrlenA(lpDest->Value.lpszA) + 1u; |
| ulCount += ulLen; |
| break; |
| case PT_UNICODE: |
| ulLen = bBadPtr ? 0 : (lstrlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR); |
| lpDest->Value.lpszW = (LPWSTR)RELOC_PTR(lpDest->Value.lpszW); |
| if (bBadPtr) |
| ulLen = (strlenW(lpDest->Value.lpszW) + 1u) * sizeof(WCHAR); |
| ulCount += ulLen; |
| break; |
| case PT_BINARY: |
| lpDest->Value.bin.lpb = (LPBYTE)RELOC_PTR(lpDest->Value.bin.lpb); |
| ulCount += lpDest->Value.bin.cb; |
| break; |
| default: |
| if (lpDest->ulPropTag & MV_FLAG) |
| { |
| /* Since we have to access the array elements, don't map the |
| * array unless it is invalid (otherwise, map it at the end) |
| */ |
| if (bBadPtr) |
| lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA); |
| |
| switch (PROP_TYPE(lpProps->ulPropTag)) |
| { |
| case PT_MV_STRING8: |
| { |
| ulCount += lpDest->Value.MVszA.cValues * sizeof(char *); |
| |
| for (i = 0; i < lpDest->Value.MVszA.cValues; i++) |
| { |
| ULONG ulStrLen = bBadPtr ? 0 : lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u; |
| |
| lpDest->Value.MVszA.lppszA[i] = (LPSTR)RELOC_PTR(lpDest->Value.MVszA.lppszA[i]); |
| if (bBadPtr) |
| ulStrLen = lstrlenA(lpDest->Value.MVszA.lppszA[i]) + 1u; |
| ulCount += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_UNICODE: |
| { |
| ulCount += lpDest->Value.MVszW.cValues * sizeof(WCHAR *); |
| |
| for (i = 0; i < lpDest->Value.MVszW.cValues; i++) |
| { |
| ULONG ulStrLen = bBadPtr ? 0 : (strlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR); |
| |
| lpDest->Value.MVszW.lppszW[i] = (LPWSTR)RELOC_PTR(lpDest->Value.MVszW.lppszW[i]); |
| if (bBadPtr) |
| ulStrLen = (strlenW(lpDest->Value.MVszW.lppszW[i]) + 1u) * sizeof(WCHAR); |
| ulCount += ulStrLen; |
| } |
| break; |
| } |
| case PT_MV_BINARY: |
| { |
| ulCount += lpDest->Value.MVszW.cValues * sizeof(SBinary); |
| |
| for (i = 0; i < lpDest->Value.MVszW.cValues; i++) |
| { |
| lpDest->Value.MVbin.lpbin[i].lpb = (LPBYTE)RELOC_PTR(lpDest->Value.MVbin.lpbin[i].lpb); |
| ulCount += lpDest->Value.MVbin.lpbin[i].cb; |
| } |
| break; |
| } |
| default: |
| ulCount += UlPropSize(lpDest); |
| break; |
| } |
| if (!bBadPtr) |
| lpDest->Value.MVszA.lppszA = (LPSTR*)RELOC_PTR(lpDest->Value.MVszA.lppszA); |
| break; |
| } |
| } |
| lpDest++; |
| } |
| if (lpCount) |
| *lpCount = ulCount; |
| |
| return S_OK; |
| } |
| |
| /************************************************************************* |
| * LpValFindProp@12 (MAPI32.173) |
| * |
| * Find a property with a given property id in a property array. |
| * |
| * PARAMS |
| * ulPropTag [I] Property tag containing property id to find |
| * cValues [I] Number of properties in lpProps |
| * lpProps [I] Property array to search |
| * |
| * RETURNS |
| * A pointer to the matching property, or NULL if none was found. |
| * |
| * NOTES |
| * This function matches only on the property id and does not care if the |
| * property types differ. |
| */ |
| LPSPropValue WINAPI LpValFindProp(ULONG ulPropTag, ULONG cValues, LPSPropValue lpProps) |
| { |
| TRACE("(%ld,%ld,%p)\n", ulPropTag, cValues, lpProps); |
| |
| if (lpProps && cValues) |
| { |
| ULONG i; |
| for (i = 0; i < cValues; i++) |
| { |
| if (PROP_ID(ulPropTag) == PROP_ID(lpProps[i].ulPropTag)) |
| return &lpProps[i]; |
| } |
| } |
| return NULL; |
| } |
| |
| /************************************************************************* |
| * ScDupPropset@16 (MAPI32.174) |
| * |
| * Duplicate a property value array into a contigous block of memory. |
| * |
| * PARAMS |
| * cValues [I] Number of properties in lpProps |
| * lpProps [I] Property array to duplicate |
| * lpAlloc [I] Memory allocation function, use MAPIAllocateBuffer() |
| * lpNewProp [O] Destination for the newly duplicated property value array |
| * |
| * RETURNS |
| * Success: S_OK. *lpNewProp contains the duplicated array. |
| * Failure: MAPI_E_INVALID_PARAMETER, if any parameter is invalid, |
| * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails. |
| */ |
| SCODE WINAPI ScDupPropset(int cValues, LPSPropValue lpProps, |
| LPALLOCATEBUFFER lpAlloc, LPSPropValue *lpNewProp) |
| { |
| ULONG ulCount; |
| SCODE sc; |
| |
| TRACE("(%d,%p,%p,%p)\n", cValues, lpProps, lpAlloc, lpNewProp); |
| |
| sc = ScCountProps(cValues, lpProps, &ulCount); |
| if (SUCCEEDED(sc)) |
| { |
| sc = lpAlloc(ulCount, (LPVOID*)lpNewProp); |
| if (SUCCEEDED(sc)) |
| sc = ScCopyProps(cValues, lpProps, *lpNewProp, &ulCount); |
| } |
| return sc; |
| } |
| |
| /************************************************************************* |
| * FBadRglpszA@8 (MAPI32.175) |
| * |
| * Determine if an array of strings is invalid |
| * |
| * PARAMS |
| * lppszStrs [I] Array of strings to check |
| * ulCount [I] Number of strings in lppszStrs |
| * |
| * RETURNS |
| * TRUE, if lppszStrs is invalid, FALSE otherwise. |
| */ |
| BOOL WINAPI FBadRglpszA(LPSTR *lppszStrs, ULONG ulCount) |
| { |
| ULONG i; |
| |
| TRACE("(%p,%ld)\n", lppszStrs, ulCount); |
| |
| if (!ulCount) |
| return FALSE; |
| |
| if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR))) |
| return TRUE; |
| |
| for (i = 0; i < ulCount; i++) |
| { |
| if (!lppszStrs[i] || IsBadStringPtrA(lppszStrs[i], -1)) |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FBadRglpszW@8 (MAPI32.176) |
| * |
| * See FBadRglpszA. |
| */ |
| BOOL WINAPI FBadRglpszW(LPWSTR *lppszStrs, ULONG ulCount) |
| { |
| ULONG i; |
| |
| TRACE("(%p,%ld)\n", lppszStrs, ulCount); |
| |
| if (!ulCount) |
| return FALSE; |
| |
| if (!lppszStrs || IsBadReadPtr(lppszStrs, ulCount * sizeof(LPWSTR))) |
| return TRUE; |
| |
| for (i = 0; i < ulCount; i++) |
| { |
| if (!lppszStrs[i] || IsBadStringPtrW(lppszStrs[i], -1)) |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FBadRowSet@4 (MAPI32.177) |
| * |
| * Determine if a row is invalid |
| * |
| * PARAMS |
| * lpRow [I] Row to check |
| * |
| * RETURNS |
| * TRUE, if lpRow is invalid, FALSE otherwise. |
| */ |
| BOOL WINAPI FBadRowSet(LPSRowSet lpRowSet) |
| { |
| ULONG i; |
| TRACE("(%p)\n", lpRowSet); |
| |
| if (!lpRowSet || IsBadReadPtr(lpRowSet, CbSRowSet(lpRowSet))) |
| return TRUE; |
| |
| for (i = 0; i < lpRowSet->cRows; i++) |
| { |
| if (FBadRow(&lpRowSet->aRow[i])) |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FBadPropTag@4 (MAPI32.179) |
| * |
| * Determine if a property tag is invalid |
| * |
| * PARAMS |
| * ulPropTag [I] Property tag to check |
| * |
| * RETURNS |
| * TRUE, if ulPropTag is invalid, FALSE otherwise. |
| */ |
| ULONG WINAPI FBadPropTag(ULONG ulPropTag) |
| { |
| TRACE("(0x%08lx)\n", ulPropTag); |
| |
| switch (ulPropTag & (~MV_FLAG & PROP_TYPE_MASK)) |
| { |
| case PT_UNSPECIFIED: |
| case PT_NULL: |
| case PT_I2: |
| case PT_LONG: |
| case PT_R4: |
| case PT_DOUBLE: |
| case PT_CURRENCY: |
| case PT_APPTIME: |
| case PT_ERROR: |
| case PT_BOOLEAN: |
| case PT_OBJECT: |
| case PT_I8: |
| case PT_STRING8: |
| case PT_UNICODE: |
| case PT_SYSTIME: |
| case PT_CLSID: |
| case PT_BINARY: |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * FBadRow@4 (MAPI32.180) |
| * |
| * Determine if a row is invalid |
| * |
| * PARAMS |
| * lpRow [I] Row to check |
| * |
| * RETURNS |
| * TRUE, if lpRow is invalid, FALSE otherwise. |
| */ |
| ULONG WINAPI FBadRow(LPSRow lpRow) |
| { |
| ULONG i; |
| TRACE("(%p)\n", lpRow); |
| |
| if (!lpRow || IsBadReadPtr(lpRow, sizeof(SRow)) || !lpRow->lpProps || |
| IsBadReadPtr(lpRow->lpProps, lpRow->cValues * sizeof(SPropValue))) |
| return TRUE; |
| |
| for (i = 0; i < lpRow->cValues; i++) |
| { |
| if (FBadProp(&lpRow->lpProps[i])) |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FBadProp@4 (MAPI32.181) |
| * |
| * Determine if a property is invalid |
| * |
| * PARAMS |
| * lpProp [I] Property to check |
| * |
| * RETURNS |
| * TRUE, if lpProp is invalid, FALSE otherwise. |
| */ |
| ULONG WINAPI FBadProp(LPSPropValue lpProp) |
| { |
| ULONG i; |
| |
| if (!lpProp || IsBadReadPtr(lpProp, sizeof(SPropValue)) || |
| FBadPropTag(lpProp->ulPropTag)) |
| return TRUE; |
| |
| switch (PROP_TYPE(lpProp->ulPropTag)) |
| { |
| /* Single value properties containing pointers */ |
| case PT_STRING8: |
| if (!lpProp->Value.lpszA || IsBadStringPtrA(lpProp->Value.lpszA, -1)) |
| return TRUE; |
| break; |
| case PT_UNICODE: |
| if (!lpProp->Value.lpszW || IsBadStringPtrW(lpProp->Value.lpszW, -1)) |
| return TRUE; |
| break; |
| case PT_BINARY: |
| if (IsBadReadPtr(lpProp->Value.bin.lpb, lpProp->Value.bin.cb)) |
| return TRUE; |
| break; |
| case PT_CLSID: |
| if (IsBadReadPtr(lpProp->Value.lpguid, sizeof(GUID))) |
| return TRUE; |
| break; |
| |
| /* Multiple value properties (arrays) containing no pointers */ |
| case PT_MV_I2: |
| return PROP_BadArray(lpProp, sizeof(SHORT)); |
| case PT_MV_LONG: |
| return PROP_BadArray(lpProp, sizeof(LONG)); |
| case PT_MV_LONGLONG: |
| return PROP_BadArray(lpProp, sizeof(LONG64)); |
| case PT_MV_FLOAT: |
| return PROP_BadArray(lpProp, sizeof(float)); |
| case PT_MV_SYSTIME: |
| return PROP_BadArray(lpProp, sizeof(FILETIME)); |
| case PT_MV_APPTIME: |
| case PT_MV_DOUBLE: |
| return PROP_BadArray(lpProp, sizeof(double)); |
| case PT_MV_CURRENCY: |
| return PROP_BadArray(lpProp, sizeof(CY)); |
| case PT_MV_CLSID: |
| return PROP_BadArray(lpProp, sizeof(GUID)); |
| |
| /* Multiple value properties containing pointers */ |
| case PT_MV_STRING8: |
| return FBadRglpszA(lpProp->Value.MVszA.lppszA, |
| lpProp->Value.MVszA.cValues); |
| case PT_MV_UNICODE: |
| return FBadRglpszW(lpProp->Value.MVszW.lppszW, |
| lpProp->Value.MVszW.cValues); |
| case PT_MV_BINARY: |
| if (PROP_BadArray(lpProp, sizeof(SBinary))) |
| return TRUE; |
| |
| for (i = 0; i < lpProp->Value.MVszW.cValues; i++) |
| { |
| if (IsBadReadPtr(lpProp->Value.MVbin.lpbin[i].lpb, |
| lpProp->Value.MVbin.lpbin[i].cb)) |
| return TRUE; |
| } |
| break; |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * FBadColumnSet@4 (MAPI32.182) |
| * |
| * Determine if an array of property tags is invalid |
| * |
| * PARAMS |
| * lpCols [I] Property tag array to check |
| * |
| * RETURNS |
| * TRUE, if lpCols is invalid, FALSE otherwise. |
| */ |
| ULONG WINAPI FBadColumnSet(LPSPropTagArray lpCols) |
| { |
| ULONG ulRet = FALSE, i; |
| |
| TRACE("(%p)\n", lpCols); |
| |
| if (!lpCols || IsBadReadPtr(lpCols, CbSPropTagArray(lpCols))) |
| ulRet = TRUE; |
| else |
| { |
| for (i = 0; i < lpCols->cValues; i++) |
| { |
| if ((lpCols->aulPropTag[i] & PROP_TYPE_MASK) == PT_ERROR || |
| FBadPropTag(lpCols->aulPropTag[i])) |
| { |
| ulRet = TRUE; |
| break; |
| } |
| } |
| } |
| TRACE("Returning %s\n", ulRet ? "TRUE" : "FALSE"); |
| return ulRet; |
| } |
