mapi32 vendor drop Added: vendor/wine/dlls/mapi32/ Added: vendor/wine/dlls/mapi32/current/ Added: vendor/wine/dlls/mapi32/current/Makefile.in Added: vendor/wine/dlls/mapi32/current/imalloc.c Added: vendor/wine/dlls/mapi32/current/mapi32.spec Added: vendor/wine/dlls/mapi32/current/mapi32_main.c Added: vendor/wine/dlls/mapi32/current/prop.c Added: vendor/wine/dlls/mapi32/current/util.c _____
Added: vendor/wine/dlls/mapi32/current/Makefile.in --- vendor/wine/dlls/mapi32/current/Makefile.in 2006-01-14 18:51:22 UTC (rev 20858) +++ vendor/wine/dlls/mapi32/current/Makefile.in 2006-01-14 19:29:26 UTC (rev 20859) @@ -0,0 +1,20 @@
+TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = mapi32.dll +IMPORTLIB = libmapi32.$(IMPLIBEXT) +IMPORTS = shlwapi ole32 user32 kernel32 ntdll +EXTRALIBS = -luuid $(LIBUNICODE) + +C_SRCS = \ + imalloc.c \ + mapi32_main.c \ + prop.c \ + util.c + +SUBDIRS = tests + +@MAKE_DLL_RULES@ + +### Dependencies: Property changes on: vendor/wine/dlls/mapi32/current/Makefile.in ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____
Added: vendor/wine/dlls/mapi32/current/imalloc.c --- vendor/wine/dlls/mapi32/current/imalloc.c 2006-01-14 18:51:22 UTC (rev 20858) +++ vendor/wine/dlls/mapi32/current/imalloc.c 2006-01-14 19:29:26 UTC (rev 20859) @@ -0,0 +1,182 @@
+/* + * MAPI Default IMalloc implementation + * + * 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 COBJMACROS +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winreg.h" +#include "winuser.h" +#include "winerror.h" +#include "winternl.h" +#include "objbase.h" +#include "shlwapi.h" +#include "mapiutil.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mapi); + +static const IMallocVtbl MAPI_IMalloc_vt; + +typedef struct +{ + const IMallocVtbl *lpVtbl; + LONG lRef; +} MAPI_IMALLOC; + +static MAPI_IMALLOC MAPI_IMalloc = { &MAPI_IMalloc_vt, 0u }; + +extern LONG MAPI_ObjectCount; /* In mapi32_main.c */ + +/********************************************************************** *** + * MAPIGetDefaultMalloc@0 (MAPI32.59) + * + * Get the default MAPI IMalloc interface. + * + * PARAMS + * None. + * + * RETURNS + * A pointer to the MAPI default allocator. + */ +LPMALLOC WINAPI MAPIGetDefaultMalloc(void) +{ + TRACE("()\n"); + + IMalloc_AddRef((LPMALLOC)&MAPI_IMalloc); + return (LPMALLOC)&MAPI_IMalloc; +} + +/********************************************************************** **** + * IMAPIMalloc_QueryInterface + */ +static HRESULT WINAPI IMAPIMalloc_fnQueryInterface(LPMALLOC iface, REFIID refiid, + LPVOID *ppvObj) +{ + TRACE("(%s,%p)\n", debugstr_guid(refiid), ppvObj); + + if (IsEqualIID(refiid, &IID_IUnknown) || + IsEqualIID(refiid, &IID_IMalloc)) + { + *ppvObj = (LPMALLOC) &MAPI_IMalloc; + TRACE("Returning IMalloc (%p)\n", *ppvObj); + return S_OK; + } + TRACE("Returning E_NOINTERFACE\n"); + return E_NOINTERFACE; +} + +/********************************************************************** **** + * IMAPIMalloc_AddRef + */ +static ULONG WINAPI IMAPIMalloc_fnAddRef(LPMALLOC iface) +{ + TRACE("(%p)\n", iface); + InterlockedIncrement(&MAPI_ObjectCount); + return 1u; +} + +/********************************************************************** **** + * IMAPIMalloc_Release + */ +static ULONG WINAPI IMAPIMalloc_fnRelease(LPMALLOC iface) +{ + TRACE("(%p)\n", iface); + InterlockedDecrement(&MAPI_ObjectCount); + return 1u; +} + +/********************************************************************** **** + * IMAPIMalloc_Alloc + */ +static LPVOID WINAPI IMAPIMalloc_fnAlloc(LPMALLOC iface, DWORD cb) +{ + TRACE("(%p)->(%ld)\n", iface, cb); + + return LocalAlloc(LMEM_FIXED, cb); +} + +/********************************************************************** **** + * IMAPIMalloc_Realloc + */ +static LPVOID WINAPI IMAPIMalloc_fnRealloc(LPMALLOC iface, LPVOID pv, DWORD cb) +{ + TRACE("(%p)->(%p, %ld)\n", iface, pv, cb); + + if (!pv) + return LocalAlloc(LMEM_FIXED, cb); + + if (cb) + return LocalReAlloc((HANDLE) pv, cb, LMEM_MOVEABLE); + + LocalFree((HANDLE) pv); + return NULL; +} + +/********************************************************************** **** + * IMAPIMalloc_Free + */ +static void WINAPI IMAPIMalloc_fnFree(LPMALLOC iface, LPVOID pv) +{ + TRACE("(%p)->(%p)\n", iface, pv); + LocalFree((HANDLE) pv); +} + +/********************************************************************** **** + * IMAPIMalloc_GetSize + */ +static DWORD WINAPI IMAPIMalloc_fnGetSize(LPMALLOC iface, LPVOID pv) +{ + TRACE("(%p)->(%p)\n", iface, pv); + return LocalSize((HANDLE) pv); +} + +/********************************************************************** **** + * IMAPIMalloc_DidAlloc + */ +static INT WINAPI IMAPIMalloc_fnDidAlloc(LPMALLOC iface, LPVOID pv) +{ + TRACE("(%p)->(%p)\n", iface, pv); + return -1; +} + +/********************************************************************** **** + * IMAPIMalloc_HeapMinimize + */ +static void WINAPI IMAPIMalloc_fnHeapMinimize(LPMALLOC iface) +{ + TRACE("(%p)\n", iface); +} + +static const IMallocVtbl MAPI_IMalloc_vt = +{ + IMAPIMalloc_fnQueryInterface, + IMAPIMalloc_fnAddRef, + IMAPIMalloc_fnRelease, + IMAPIMalloc_fnAlloc, + IMAPIMalloc_fnRealloc, + IMAPIMalloc_fnFree, + IMAPIMalloc_fnGetSize, + IMAPIMalloc_fnDidAlloc, + IMAPIMalloc_fnHeapMinimize +}; Property changes on: vendor/wine/dlls/mapi32/current/imalloc.c ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____
Added: vendor/wine/dlls/mapi32/current/mapi32.spec --- vendor/wine/dlls/mapi32/current/mapi32.spec 2006-01-14 18:51:22 UTC (rev 20858) +++ vendor/wine/dlls/mapi32/current/mapi32.spec 2006-01-14 19:29:26 UTC (rev 20859) @@ -0,0 +1,191 @@
+ 8 stub @ + 10 stdcall MAPILogonEx(long ptr ptr long ptr) + 11 stdcall MAPILogonEx@20(long ptr ptr long ptr) MAPILogonEx + 12 stdcall MAPIAllocateBuffer(long ptr) + 13 stdcall MAPIAllocateBuffer@8(long ptr) MAPIAllocateBuffer + 14 stdcall MAPIAllocateMore(long ptr ptr) + 15 stdcall MAPIAllocateMore@12(long ptr ptr) MAPIAllocateMore + 16 stdcall MAPIFreeBuffer(ptr) + 17 stdcall MAPIFreeBuffer@4(ptr) MAPIFreeBuffer + 18 stub MAPIAdminProfiles + 19 stub MAPIAdminProfiles@8 + 20 stdcall MAPIInitialize(ptr) + 21 stdcall MAPIInitialize@4(ptr) MAPIInitialize + 22 stdcall MAPIUninitialize() + 23 stdcall MAPIUninitialize@0() MAPIUninitialize + 24 stub PRProviderInit + 25 stub LAUNCHWIZARD + 26 stub LaunchWizard@20 + 27 stub DllGetClassObject + 28 stdcall -private DllCanUnloadNow() + 29 stub MAPIOpenFormMgr + 30 stub MAPIOpenFormMgr@8 + 31 stub MAPIOpenLocalFormContainer + 32 stub MAPIOpenLocalFormContainer@4 + 33 stdcall ScInitMapiUtil@4(long) ScInitMapiUtil + 34 stdcall DeinitMapiUtil@0() DeinitMapiUtil + 35 stub ScGenerateMuid@4 + 36 stub HrAllocAdviseSink@12 + 41 stdcall WrapProgress@20(ptr ptr ptr ptr ptr) WrapProgress + 42 stdcall HrThisThreadAdviseSink@8(ptr ptr) HrThisThreadAdviseSink + 43 stub ScBinFromHexBounded@12 + 44 stdcall FBinFromHex@8(ptr ptr) FBinFromHex + 45 stdcall HexFromBin@12(ptr long ptr) HexFromBin + 46 stub BuildDisplayTable@40 + 47 stdcall SwapPlong@8(ptr long) SwapPlong + 48 stdcall SwapPword@8(ptr long) SwapPword + 49 stub MAPIInitIdle@4 + 50 stub MAPIDeinitIdle@0 + 51 stub InstallFilterHook@4 + 52 stub FtgRegisterIdleRoutine@20 + 53 stub EnableIdleRoutine@8 + 54 stub DeregisterIdleRoutine@4 + 55 stub ChangeIdleRoutine@28 + 59 stdcall MAPIGetDefaultMalloc@0() MAPIGetDefaultMalloc + 60 stdcall CreateIProp@24(ptr ptr ptr ptr ptr ptr) CreateIProp + 61 stub CreateTable@36 + 62 stdcall MNLS_lstrlenW@4(wstr) MNLS_lstrlenW + 63 stdcall MNLS_lstrcmpW@8(wstr wstr) MNLS_lstrcmpW + 64 stdcall MNLS_lstrcpyW@8(ptr wstr) MNLS_lstrcpyW + 65 stdcall MNLS_CompareStringW@24(long wstr wstr) MNLS_CompareStringW + 66 stdcall MNLS_MultiByteToWideChar@24(long long str long ptr long) kernel32.MultiByteToWideChar + 67 stdcall MNLS_WideCharToMultiByte@32(long long wstr long ptr long ptr ptr) kernel32.WideCharToMultiByte + 68 stdcall MNLS_IsBadStringPtrW@8(ptr long) kernel32.IsBadStringPtrW + 72 stdcall FEqualNames@8(ptr ptr) FEqualNames + 73 stub WrapStoreEntryID@24 + 74 stdcall IsBadBoundedStringPtr@8(ptr long) IsBadBoundedStringPtr + 75 stub HrQueryAllRows@24 + 76 stdcall PropCopyMore@16(ptr ptr ptr ptr) PropCopyMore + 77 stdcall UlPropSize@4(ptr) UlPropSize + 78 stdcall FPropContainsProp@12(ptr ptr long) FPropContainsProp + 79 stdcall FPropCompareProp@12(ptr long ptr) FPropCompareProp + 80 stdcall LPropCompareProp@8(ptr ptr) LPropCompareProp + 81 stub HrAddColumns@16 + 82 stub HrAddColumnsEx@20 +121 stdcall -ret64 FtAddFt@16(double double) MAPI32_FtAddFt +122 stub FtAdcFt@20 +123 stdcall -ret64 FtSubFt@16(double double) MAPI32_FtSubFt +124 stdcall -ret64 FtMulDw@12(long double) MAPI32_FtMulDw +125 stdcall -ret64 FtMulDwDw@8(long long) MAPI32_FtMulDwDw +126 stdcall -ret64 FtNegFt@8(double) MAPI32_FtNegFt +127 stub FtDivFtBogus@20 +128 stdcall UlAddRef@4(ptr) UlAddRef +129 stdcall UlRelease@4(ptr) UlRelease +130 stdcall SzFindCh@8(str long) shlwapi.StrChrA +131 stdcall SzFindLastCh@8(str str long) shlwapi.StrRChrA +132 stdcall SzFindSz@8(str str) shlwapi.StrStrA +133 stdcall UFromSz@4(str) UFromSz +135 stdcall HrGetOneProp@12(ptr long ptr) HrGetOneProp +136 stdcall HrSetOneProp@8(ptr ptr) HrSetOneProp +137 stdcall FPropExists@8(ptr long) FPropExists +138 stdcall PpropFindProp@12(ptr long long) PpropFindProp +139 stdcall FreePadrlist@4(ptr) FreePadrlist +140 stdcall FreeProws@4(ptr) FreeProws +141 stub HrSzFromEntryID@12 +142 stub HrEntryIDFromSz@12 +143 stub HrComposeEID@28 +144 stub HrDecomposeEID@28 +145 stub HrComposeMsgID@24 +146 stub HrDecomposeMsgID@24 +147 stdcall OpenStreamOnFile@24(ptr ptr ptr ptr ptr ptr) OpenStreamOnFile +148 stdcall OpenStreamOnFile(ptr ptr ptr ptr ptr ptr) +149 stub OpenTnefStream@28 +150 stub OpenTnefStream +151 stub OpenTnefStreamEx@32 +152 stub OpenTnefStreamEx +153 stub GetTnefStreamCodepage@12 +154 stub GetTnefStreamCodepage +155 stdcall UlFromSzHex@4(ptr) UlFromSzHex +156 stub UNKOBJ_ScAllocate@12 +157 stub UNKOBJ_ScAllocateMore@16 +158 stub UNKOBJ_Free@8 +159 stub UNKOBJ_FreeRows@8 +160 stub UNKOBJ_ScCOAllocate@12 +161 stub UNKOBJ_ScCOReallocate@12 +162 stub UNKOBJ_COFree@8 +163 stub UNKOBJ_ScSzFromIdsAlloc@20 +164 stub ScCountNotifications@12 +165 stub ScCopyNotifications@16 +166 stub ScRelocNotifications@20 +170 stdcall ScCountProps@12(long ptr ptr) ScCountProps +171 stdcall ScCopyProps@16(long ptr ptr ptr) ScCopyProps +172 stdcall ScRelocProps@20(long ptr ptr ptr ptr) ScRelocProps +173 stdcall LpValFindProp@12(long long ptr) LpValFindProp +174 stdcall ScDupPropset@16(long ptr ptr ptr) ScDupPropset +175 stdcall FBadRglpszA@8(ptr long) FBadRglpszA +176 stdcall FBadRglpszW@8(ptr long) FBadRglpszW +177 stdcall FBadRowSet@4(ptr) FBadRowSet +178 stub FBadRglpNameID@8 +179 stdcall FBadPropTag@4(long) FBadPropTag +180 stdcall FBadRow@4(ptr) FBadRow +181 stdcall FBadProp@4(ptr) FBadProp +182 stdcall FBadColumnSet@4(ptr) FBadColumnSet +183 stub RTFSync@12 +184 stub RTFSync +185 stub WrapCompressedRTFStream@12 +186 stub WrapCompressedRTFStream +187 stub __ValidateParameters@8 +188 stub __CPPValidateParameters@8 +189 stub FBadSortOrderSet@4 +190 stdcall FBadEntryList@4(ptr) FBadEntryList +191 stub FBadRestriction@4 +192 stub ScUNCFromLocalPath@12 +193 stub ScLocalPathFromUNC@12 +194 stub HrIStorageFromStream@16 +195 stub HrValidateIPMSubtree@20 +196 stub OpenIMsgSession@12 +197 stub CloseIMsgSession@4 +198 stub OpenIMsgOnIStg@44 +199 stub SetAttribIMsgOnIStg@16 +200 stub GetAttribIMsgOnIStg@12 +201 stub MapStorageSCode@4 +202 stub ScMAPIXFromCMC +203 stub ScMAPIXFromSMAPI +204 stub EncodeID@12 +205 stub FDecodeID@12 +206 stub CchOfEncoding@4 +207 stdcall CbOfEncoded@4(ptr) CbOfEncoded +208 stub MAPISendDocuments +209 stdcall MAPILogon(long ptr ptr long long ptr) +210 stub MAPILogoff +211 stub MAPISendMail +212 stub MAPISaveMail +213 stub MAPIReadMail +214 stub MAPIFindNext +215 stub MAPIDeleteMail +217 stub MAPIAddress +218 stub MAPIDetails +219 stub MAPIResolveName +220 stub BMAPISendMail +221 stub BMAPISaveMail +222 stub BMAPIReadMail +223 stub BMAPIGetReadMail +224 stub BMAPIFindNext +225 stub BMAPIAddress +226 stub BMAPIGetAddress +227 stub BMAPIDetails +228 stub BMAPIResolveName +229 stub cmc_act_on +230 stub cmc_free +231 stub cmc_list +232 stub cmc_logoff +233 stub cmc_logon +234 stub cmc_look_up +235 stdcall cmc_query_configuration( long long ptr ptr ) +236 stub cmc_read +237 stub cmc_send +238 stub cmc_send_documents +239 stub HrDispatchNotifications@4 +241 stub HrValidateParameters@8 +244 stub ScCreateConversationIndex@16 +246 stub HrGetOmiProvidersFlags +247 stub HrGetOmiProvidersFlags@8 +248 stub HrSetOmiProvidersFlagsInvalid +249 stub HrSetOmiProvidersFlagsInvalid@4 +250 stub GetOutlookVersion +251 stub GetOutlookVersion@0 +252 stub FixMAPI +253 stub FixMAPI@0 +# This entry point is sometimes used to detect if the mapi dll came from Outlook +#254 stub FGetComponentPath +#255 stub FGetComponentPath@20 _____
Added: vendor/wine/dlls/mapi32/current/mapi32_main.c --- vendor/wine/dlls/mapi32/current/mapi32_main.c 2006-01-14 18:51:22 UTC (rev 20858) +++ vendor/wine/dlls/mapi32/current/mapi32_main.c 2006-01-14 19:29:26 UTC (rev 20859) @@ -0,0 +1,94 @@
+/* + * MAPI basics + * + * Copyright 2001 CodeWeavers Inc. + * + * 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> + +#include "windef.h" +#include "winbase.h" +#include "winerror.h" +#include "objbase.h" +#include "mapix.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mapi); + +LONG MAPI_ObjectCount = 0; + +/********************************************************************** * + * DllMain (MAPI32.init) + */ +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad) +{ + TRACE("(%p,%ld,%p)\n", hinstDLL, fdwReason, fImpLoad); + + switch (fdwReason) + { + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hinstDLL); + break; + case DLL_PROCESS_DETACH: + TRACE("DLL_PROCESS_DETACH: %ld objects remaining\n", MAPI_ObjectCount); + break; + } + return TRUE; +} + +/********************************************************************** * + * DllCanUnloadNow (MAPI32.28) + * + * Determine if this dll can be unloaded from the callers address space. + * + * PARAMS + * None. + * + * RETURNS + * S_OK, if the dll can be unloaded, + * S_FALSE, otherwise. + */ +HRESULT WINAPI DllCanUnloadNow(void) +{ + return MAPI_ObjectCount == 0 ? S_OK : S_FALSE; +} + +HRESULT WINAPI MAPIInitialize ( LPVOID lpMapiInit ) +{ + ERR("Stub\n"); + return MAPI_E_NOT_INITIALIZED; +} + +ULONG WINAPI MAPILogon(ULONG ulUIParam, LPSTR lpszProfileName, LPSTR +lpszPassword, FLAGS flFlags, ULONG ulReserver, LPLHANDLE lplhSession) +{ + ERR("Stub\n"); + return MAPI_E_LOGON_FAILED; +} + +HRESULT WINAPI MAPILogonEx(ULONG_PTR ulUIParam, LPWSTR lpszProfileName, + LPWSTR lpszPassword, ULONG flFlags, + LPMAPISESSION *lppSession) +{ + ERR("Stub\n"); + return MAPI_E_LOGON_FAILED; +} + +VOID WINAPI MAPIUninitialize(void) +{ + ERR("Stub\n"); +} Property changes on: vendor/wine/dlls/mapi32/current/mapi32_main.c ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____
Added: vendor/wine/dlls/mapi32/current/prop.c --- vendor/wine/dlls/mapi32/current/prop.c 2006-01-14 18:51:22 UTC (rev 20858) +++ vendor/wine/dlls/mapi32/current/prop.c 2006-01-14 19:29:26 UTC (rev 20859) @@ -0,0 +1,2549 @@
+/* + * 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/list.h" +#include "wine/debug.h" +#include "wine/unicode.h" +#include "mapival.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mapi); + +BOOL WINAPI FBadRglpszA(LPSTR*,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; + 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; [truncated at 1000 lines; 2919 more skipped]
-
gvg＠svn.reactos.org