[gvg] 20859: mapi32 vendor drop

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]