mirror of
https://github.com/reactos/reactos.git
synced 2024-10-31 03:48:17 +00:00
1142 lines
34 KiB
C
1142 lines
34 KiB
C
/*
|
|
* MAPI Utility functions
|
|
*
|
|
* Copyright 2004 Jon Griffiths
|
|
* Copyright 2009 Owen Rudge for CodeWeavers
|
|
*
|
|
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
#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 "wine/debug.h"
|
|
#include "mapival.h"
|
|
#include "xcmc.h"
|
|
#include "msi.h"
|
|
#include "util.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(mapi);
|
|
|
|
static const BYTE digitsToHex[] = {
|
|
0,1,2,3,4,5,6,7,8,9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,10,11,12,13,14,15,
|
|
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
|
|
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,10,11,12,13,
|
|
14,15 };
|
|
|
|
MAPI_FUNCTIONS mapiFunctions;
|
|
|
|
/**************************************************************************
|
|
* ScInitMapiUtil (MAPI32.33)
|
|
*
|
|
* Initialise Mapi utility functions.
|
|
*
|
|
* PARAMS
|
|
* ulReserved [I] Reserved, pass 0.
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. Mapi utility functions may be called.
|
|
* Failure: MAPI_E_INVALID_PARAMETER, if ulReserved is not 0.
|
|
*
|
|
* NOTES
|
|
* Your application does not need to call this function unless it does not
|
|
* call MAPIInitialize()/MAPIUninitialize().
|
|
*/
|
|
SCODE WINAPI ScInitMapiUtil(ULONG ulReserved)
|
|
{
|
|
if (mapiFunctions.ScInitMapiUtil)
|
|
return mapiFunctions.ScInitMapiUtil(ulReserved);
|
|
|
|
FIXME("(0x%08x)stub!\n", ulReserved);
|
|
if (ulReserved)
|
|
return MAPI_E_INVALID_PARAMETER;
|
|
return S_OK;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* DeinitMapiUtil (MAPI32.34)
|
|
*
|
|
* Uninitialise Mapi utility functions.
|
|
*
|
|
* PARAMS
|
|
* None.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*
|
|
* NOTES
|
|
* Your application does not need to call this function unless it does not
|
|
* call MAPIInitialize()/MAPIUninitialize().
|
|
*/
|
|
VOID WINAPI DeinitMapiUtil(void)
|
|
{
|
|
if (mapiFunctions.DeinitMapiUtil)
|
|
mapiFunctions.DeinitMapiUtil();
|
|
else
|
|
FIXME("()stub!\n");
|
|
}
|
|
|
|
typedef LPVOID *LPMAPIALLOCBUFFER;
|
|
|
|
/**************************************************************************
|
|
* MAPIAllocateBuffer (MAPI32.12)
|
|
* MAPIAllocateBuffer@8 (MAPI32.13)
|
|
*
|
|
* Allocate a block of memory.
|
|
*
|
|
* PARAMS
|
|
* cbSize [I] Size of the block to allocate in bytes
|
|
* lppBuffer [O] Destination for pointer to allocated memory
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. *lppBuffer is filled with a pointer to a memory block of
|
|
* length cbSize bytes.
|
|
* Failure: MAPI_E_INVALID_PARAMETER, if lppBuffer is NULL.
|
|
* MAPI_E_NOT_ENOUGH_MEMORY, if the memory allocation fails.
|
|
*
|
|
* NOTES
|
|
* Memory allocated with this function should be freed with MAPIFreeBuffer().
|
|
* Further allocations of memory may be linked to the pointer returned using
|
|
* MAPIAllocateMore(). Linked allocations are freed when the initial pointer
|
|
* is feed.
|
|
*/
|
|
SCODE WINAPI MAPIAllocateBuffer(ULONG cbSize, LPVOID *lppBuffer)
|
|
{
|
|
LPMAPIALLOCBUFFER lpBuff;
|
|
|
|
TRACE("(%d,%p)\n", cbSize, lppBuffer);
|
|
|
|
if (mapiFunctions.MAPIAllocateBuffer)
|
|
return mapiFunctions.MAPIAllocateBuffer(cbSize, lppBuffer);
|
|
|
|
if (!lppBuffer)
|
|
return E_INVALIDARG;
|
|
|
|
lpBuff = HeapAlloc(GetProcessHeap(), 0, cbSize + sizeof(*lpBuff));
|
|
if (!lpBuff)
|
|
return MAPI_E_NOT_ENOUGH_MEMORY;
|
|
|
|
TRACE("initial allocation:%p, returning %p\n", lpBuff, lpBuff + 1);
|
|
*lpBuff++ = NULL;
|
|
*lppBuffer = lpBuff;
|
|
return S_OK;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* MAPIAllocateMore (MAPI32.14)
|
|
* MAPIAllocateMore@12 (MAPI32.15)
|
|
*
|
|
* Allocate a block of memory linked to a previous allocation.
|
|
*
|
|
* PARAMS
|
|
* cbSize [I] Size of the block to allocate in bytes
|
|
* lpOrig [I] Initial allocation to link to, from MAPIAllocateBuffer()
|
|
* lppBuffer [O] Destination for pointer to allocated memory
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. *lppBuffer is filled with a pointer to a memory block of
|
|
* length cbSize bytes.
|
|
* Failure: MAPI_E_INVALID_PARAMETER, if lpOrig or lppBuffer is invalid.
|
|
* MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
|
|
*
|
|
* NOTES
|
|
* Memory allocated with this function and stored in *lppBuffer is freed
|
|
* when lpOrig is passed to MAPIFreeBuffer(). It should not be freed independently.
|
|
*/
|
|
SCODE WINAPI MAPIAllocateMore(ULONG cbSize, LPVOID lpOrig, LPVOID *lppBuffer)
|
|
{
|
|
LPMAPIALLOCBUFFER lpBuff = lpOrig;
|
|
|
|
TRACE("(%d,%p,%p)\n", cbSize, lpOrig, lppBuffer);
|
|
|
|
if (mapiFunctions.MAPIAllocateMore)
|
|
return mapiFunctions.MAPIAllocateMore(cbSize, lpOrig, lppBuffer);
|
|
|
|
if (!lppBuffer || !lpBuff || !--lpBuff)
|
|
return E_INVALIDARG;
|
|
|
|
/* Find the last allocation in the chain */
|
|
while (*lpBuff)
|
|
{
|
|
TRACE("linked:%p->%p\n", lpBuff, *lpBuff);
|
|
lpBuff = *lpBuff;
|
|
}
|
|
|
|
if (SUCCEEDED(MAPIAllocateBuffer(cbSize, lppBuffer)))
|
|
{
|
|
*lpBuff = ((LPMAPIALLOCBUFFER)*lppBuffer) - 1;
|
|
TRACE("linking %p->%p\n", lpBuff, *lpBuff);
|
|
}
|
|
return *lppBuffer ? S_OK : MAPI_E_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* MAPIFreeBuffer (MAPI32.16)
|
|
* MAPIFreeBuffer@4 (MAPI32.17)
|
|
*
|
|
* Free a block of memory and any linked allocations associated with it.
|
|
*
|
|
* PARAMS
|
|
* lpBuffer [I] Memory to free, returned from MAPIAllocateBuffer()
|
|
*
|
|
* RETURNS
|
|
* S_OK.
|
|
*/
|
|
ULONG WINAPI MAPIFreeBuffer(LPVOID lpBuffer)
|
|
{
|
|
LPMAPIALLOCBUFFER lpBuff = lpBuffer;
|
|
|
|
TRACE("(%p)\n", lpBuffer);
|
|
|
|
if (mapiFunctions.MAPIFreeBuffer)
|
|
return mapiFunctions.MAPIFreeBuffer(lpBuffer);
|
|
|
|
if (lpBuff && --lpBuff)
|
|
{
|
|
while (lpBuff)
|
|
{
|
|
LPVOID lpFree = lpBuff;
|
|
|
|
lpBuff = *lpBuff;
|
|
|
|
TRACE("linked:%p->%p, freeing %p\n", lpFree, lpBuff, lpFree);
|
|
HeapFree(GetProcessHeap(), 0, lpFree);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* WrapProgress@20 (MAPI32.41)
|
|
*/
|
|
HRESULT WINAPI WrapProgress(PVOID unk1, PVOID unk2, PVOID unk3, PVOID unk4, PVOID unk5)
|
|
{
|
|
/* Native does not implement this function */
|
|
return MAPI_E_NO_SUPPORT;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* HrDispatchNotifications@4 (MAPI32.239)
|
|
*/
|
|
HRESULT WINAPI HrDispatchNotifications(ULONG flags)
|
|
{
|
|
FIXME("(%08x)\n", flags);
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* HrThisThreadAdviseSink@8 (MAPI32.42)
|
|
*
|
|
* Ensure that an advise sink is only notified in its originating thread.
|
|
*
|
|
* PARAMS
|
|
* lpSink [I] IMAPIAdviseSink interface to be protected
|
|
* lppNewSink [I] Destination for wrapper IMAPIAdviseSink interface
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. *lppNewSink contains a new sink to use in place of lpSink.
|
|
* Failure: E_INVALIDARG, if any parameter is invalid.
|
|
*/
|
|
HRESULT WINAPI HrThisThreadAdviseSink(LPMAPIADVISESINK lpSink, LPMAPIADVISESINK* lppNewSink)
|
|
{
|
|
if (mapiFunctions.HrThisThreadAdviseSink)
|
|
return mapiFunctions.HrThisThreadAdviseSink(lpSink, lppNewSink);
|
|
|
|
FIXME("(%p,%p)semi-stub\n", lpSink, lppNewSink);
|
|
|
|
if (!lpSink || !lppNewSink)
|
|
return E_INVALIDARG;
|
|
|
|
/* Don't wrap the sink for now, just copy it */
|
|
*lppNewSink = lpSink;
|
|
IMAPIAdviseSink_AddRef(lpSink);
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* FBinFromHex (MAPI32.44)
|
|
*
|
|
* Create an array of binary data from a string.
|
|
*
|
|
* PARAMS
|
|
* lpszHex [I] String to convert to binary data
|
|
* lpOut [O] Destination for resulting binary data
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE. lpOut contains the decoded binary data.
|
|
* Failure: FALSE, if lpszHex does not represent a binary string.
|
|
*
|
|
* NOTES
|
|
* - lpOut must be at least half the length of lpszHex in bytes.
|
|
* - Although the Mapi headers prototype this function as both
|
|
* Ascii and Unicode, there is only one (Ascii) implementation. This
|
|
* means that lpszHex is treated as an Ascii string (i.e. a single NUL
|
|
* character in the byte stream terminates the string).
|
|
*/
|
|
BOOL WINAPI FBinFromHex(LPWSTR lpszHex, LPBYTE lpOut)
|
|
{
|
|
LPSTR lpStr = (LPSTR)lpszHex;
|
|
|
|
TRACE("(%p,%p)\n", lpszHex, lpOut);
|
|
|
|
while (*lpStr)
|
|
{
|
|
if (lpStr[0] < '0' || lpStr[0] > 'f' || digitsToHex[lpStr[0] - '0'] == 0xff ||
|
|
lpStr[1] < '0' || lpStr[1] > 'f' || digitsToHex[lpStr[1] - '0'] == 0xff)
|
|
return FALSE;
|
|
|
|
*lpOut++ = (digitsToHex[lpStr[0] - '0'] << 4) | digitsToHex[lpStr[1] - '0'];
|
|
lpStr += 2;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* HexFromBin (MAPI32.45)
|
|
*
|
|
* Create a string from an array of binary data.
|
|
*
|
|
* PARAMS
|
|
* lpHex [I] Binary data to convert to string
|
|
* iCount [I] Length of lpHex in bytes
|
|
* lpszOut [O] Destination for resulting hex string
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*
|
|
* NOTES
|
|
* - lpszOut must be at least 2 * iCount + 1 bytes characters long.
|
|
* - Although the Mapi headers prototype this function as both
|
|
* Ascii and Unicode, there is only one (Ascii) implementation. This
|
|
* means that the resulting string is not properly NUL terminated
|
|
* if the caller expects it to be a Unicode string.
|
|
*/
|
|
void WINAPI HexFromBin(LPBYTE lpHex, int iCount, LPWSTR lpszOut)
|
|
{
|
|
static const char hexDigits[] = { "0123456789ABCDEF" };
|
|
LPSTR lpStr = (LPSTR)lpszOut;
|
|
|
|
TRACE("(%p,%d,%p)\n", lpHex, iCount, lpszOut);
|
|
|
|
while (iCount-- > 0)
|
|
{
|
|
*lpStr++ = hexDigits[*lpHex >> 4];
|
|
*lpStr++ = hexDigits[*lpHex & 0xf];
|
|
lpHex++;
|
|
}
|
|
*lpStr = '\0';
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SwapPlong@8 (MAPI32.47)
|
|
*
|
|
* Swap the bytes in a ULONG array.
|
|
*
|
|
* PARAMS
|
|
* lpData [O] Array to swap bytes in
|
|
* ulLen [I] Number of ULONG element to swap the bytes of
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
VOID WINAPI SwapPlong(PULONG lpData, ULONG ulLen)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < ulLen; i++)
|
|
lpData[i] = RtlUlongByteSwap(lpData[i]);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SwapPword@8 (MAPI32.48)
|
|
*
|
|
* Swap the bytes in a USHORT array.
|
|
*
|
|
* PARAMS
|
|
* lpData [O] Array to swap bytes in
|
|
* ulLen [I] Number of USHORT element to swap the bytes of
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
VOID WINAPI SwapPword(PUSHORT lpData, ULONG ulLen)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < ulLen; i++)
|
|
lpData[i] = RtlUshortByteSwap(lpData[i]);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* MNLS_lstrlenW@4 (MAPI32.62)
|
|
*
|
|
* Calculate the length of a Unicode string.
|
|
*
|
|
* PARAMS
|
|
* lpszStr [I] String to calculate the length of
|
|
*
|
|
* RETURNS
|
|
* The length of lpszStr in Unicode characters.
|
|
*/
|
|
ULONG WINAPI MNLS_lstrlenW(LPCWSTR lpszStr)
|
|
{
|
|
TRACE("(%s)\n", debugstr_w(lpszStr));
|
|
return lstrlenW(lpszStr);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* MNLS_lstrcmpW@8 (MAPI32.63)
|
|
*
|
|
* Compare two Unicode strings.
|
|
*
|
|
* PARAMS
|
|
* lpszLeft [I] First string to compare
|
|
* lpszRight [I] Second string to compare
|
|
*
|
|
* RETURNS
|
|
* An integer less than, equal to or greater than 0, indicating that
|
|
* lpszLeft is less than, the same, or greater than lpszRight.
|
|
*/
|
|
INT WINAPI MNLS_lstrcmpW(LPCWSTR lpszLeft, LPCWSTR lpszRight)
|
|
{
|
|
TRACE("(%s,%s)\n", debugstr_w(lpszLeft), debugstr_w(lpszRight));
|
|
return lstrcmpW(lpszLeft, lpszRight);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* MNLS_lstrcpyW@8 (MAPI32.64)
|
|
*
|
|
* Copy a Unicode string to another string.
|
|
*
|
|
* PARAMS
|
|
* lpszDest [O] Destination string
|
|
* lpszSrc [I] Source string
|
|
*
|
|
* RETURNS
|
|
* The length lpszDest in Unicode characters.
|
|
*/
|
|
ULONG WINAPI MNLS_lstrcpyW(LPWSTR lpszDest, LPCWSTR lpszSrc)
|
|
{
|
|
ULONG len;
|
|
|
|
TRACE("(%p,%s)\n", lpszDest, debugstr_w(lpszSrc));
|
|
len = (lstrlenW(lpszSrc) + 1) * sizeof(WCHAR);
|
|
memcpy(lpszDest, lpszSrc, len);
|
|
return len;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* MNLS_CompareStringW@12 (MAPI32.65)
|
|
*
|
|
* Compare two Unicode strings.
|
|
*
|
|
* PARAMS
|
|
* dwCp [I] Code page for the comparison
|
|
* lpszLeft [I] First string to compare
|
|
* lpszRight [I] Second string to compare
|
|
*
|
|
* RETURNS
|
|
* CSTR_LESS_THAN, CSTR_EQUAL or CSTR_GREATER_THAN, indicating that
|
|
* lpszLeft is less than, the same, or greater than lpszRight.
|
|
*/
|
|
INT WINAPI MNLS_CompareStringW(DWORD dwCp, LPCWSTR lpszLeft, LPCWSTR lpszRight)
|
|
{
|
|
INT ret;
|
|
|
|
TRACE("0x%08x,%s,%s\n", dwCp, debugstr_w(lpszLeft), debugstr_w(lpszRight));
|
|
ret = MNLS_lstrcmpW(lpszLeft, lpszRight);
|
|
return ret < 0 ? CSTR_LESS_THAN : ret ? CSTR_GREATER_THAN : CSTR_EQUAL;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FEqualNames@8 (MAPI32.72)
|
|
*
|
|
* Compare two Mapi names.
|
|
*
|
|
* PARAMS
|
|
* lpName1 [I] First name to compare to lpName2
|
|
* lpName2 [I] Second name to compare to lpName1
|
|
*
|
|
* RETURNS
|
|
* TRUE, if the names are the same,
|
|
* FALSE, Otherwise.
|
|
*/
|
|
BOOL WINAPI FEqualNames(LPMAPINAMEID lpName1, LPMAPINAMEID lpName2)
|
|
{
|
|
TRACE("(%p,%p)\n", lpName1, lpName2);
|
|
|
|
if (!lpName1 || !lpName2 ||
|
|
!IsEqualGUID(lpName1->lpguid, lpName2->lpguid) ||
|
|
lpName1->ulKind != lpName2->ulKind)
|
|
return FALSE;
|
|
|
|
if (lpName1->ulKind == MNID_STRING)
|
|
return !lstrcmpW(lpName1->Kind.lpwstrName, lpName2->Kind.lpwstrName);
|
|
|
|
return lpName1->Kind.lID == lpName2->Kind.lID;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IsBadBoundedStringPtr@8 (MAPI32.71)
|
|
*
|
|
* Determine if a string pointer is valid.
|
|
*
|
|
* PARAMS
|
|
* lpszStr [I] String to check
|
|
* ulLen [I] Maximum length of lpszStr
|
|
*
|
|
* RETURNS
|
|
* TRUE, if lpszStr is invalid or longer than ulLen,
|
|
* FALSE, otherwise.
|
|
*/
|
|
BOOL WINAPI IsBadBoundedStringPtr(LPCSTR lpszStr, ULONG ulLen)
|
|
{
|
|
if (!lpszStr || IsBadStringPtrA(lpszStr, -1) || strlen(lpszStr) >= ulLen)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FtAddFt@16 (MAPI32.121)
|
|
*
|
|
* Add two FILETIME's together.
|
|
*
|
|
* PARAMS
|
|
* ftLeft [I] FILETIME to add to ftRight
|
|
* ftRight [I] FILETIME to add to ftLeft
|
|
*
|
|
* RETURNS
|
|
* The sum of ftLeft and ftRight
|
|
*/
|
|
LONGLONG WINAPI MAPI32_FtAddFt(FILETIME ftLeft, FILETIME ftRight)
|
|
{
|
|
LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
|
|
|
|
return *pl + *pr;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FtSubFt@16 (MAPI32.123)
|
|
*
|
|
* Subtract two FILETIME's together.
|
|
*
|
|
* PARAMS
|
|
* ftLeft [I] Initial FILETIME
|
|
* ftRight [I] FILETIME to subtract from ftLeft
|
|
*
|
|
* RETURNS
|
|
* The remainder after ftRight is subtracted from ftLeft.
|
|
*/
|
|
LONGLONG WINAPI MAPI32_FtSubFt(FILETIME ftLeft, FILETIME ftRight)
|
|
{
|
|
LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
|
|
|
|
return *pr - *pl;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FtMulDw@12 (MAPI32.124)
|
|
*
|
|
* Multiply a FILETIME by a DWORD.
|
|
*
|
|
* PARAMS
|
|
* dwLeft [I] DWORD to multiply with ftRight
|
|
* ftRight [I] FILETIME to multiply with dwLeft
|
|
*
|
|
* RETURNS
|
|
* The product of dwLeft and ftRight
|
|
*/
|
|
LONGLONG WINAPI MAPI32_FtMulDw(DWORD dwLeft, FILETIME ftRight)
|
|
{
|
|
LONGLONG *pr = (LONGLONG*)&ftRight;
|
|
|
|
return (LONGLONG)dwLeft * (*pr);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FtMulDwDw@8 (MAPI32.125)
|
|
*
|
|
* Multiply two DWORD, giving the result as a FILETIME.
|
|
*
|
|
* PARAMS
|
|
* dwLeft [I] DWORD to multiply with dwRight
|
|
* dwRight [I] DWORD to multiply with dwLeft
|
|
*
|
|
* RETURNS
|
|
* The product of ftMultiplier and ftMultiplicand as a FILETIME.
|
|
*/
|
|
LONGLONG WINAPI MAPI32_FtMulDwDw(DWORD dwLeft, DWORD dwRight)
|
|
{
|
|
return (LONGLONG)dwLeft * (LONGLONG)dwRight;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FtNegFt@8 (MAPI32.126)
|
|
*
|
|
* Negate a FILETIME.
|
|
*
|
|
* PARAMS
|
|
* ft [I] FILETIME to negate
|
|
*
|
|
* RETURNS
|
|
* The negation of ft.
|
|
*/
|
|
LONGLONG WINAPI MAPI32_FtNegFt(FILETIME ft)
|
|
{
|
|
LONGLONG *p = (LONGLONG*)&ft;
|
|
|
|
return - *p;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* UlAddRef@4 (MAPI32.128)
|
|
*
|
|
* Add a reference to an object.
|
|
*
|
|
* PARAMS
|
|
* lpUnk [I] Object to add a reference to.
|
|
*
|
|
* RETURNS
|
|
* The new reference count of the object, or 0 if lpUnk is NULL.
|
|
*
|
|
* NOTES
|
|
* See IUnknown_AddRef.
|
|
*/
|
|
ULONG WINAPI UlAddRef(void *lpUnk)
|
|
{
|
|
TRACE("(%p)\n", lpUnk);
|
|
|
|
if (!lpUnk)
|
|
return 0UL;
|
|
return IUnknown_AddRef((LPUNKNOWN)lpUnk);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* UlRelease@4 (MAPI32.129)
|
|
*
|
|
* Remove a reference from an object.
|
|
*
|
|
* PARAMS
|
|
* lpUnk [I] Object to remove reference from.
|
|
*
|
|
* RETURNS
|
|
* The new reference count of the object, or 0 if lpUnk is NULL. If lpUnk is
|
|
* non-NULL and this function returns 0, the object pointed to by lpUnk has
|
|
* been released.
|
|
*
|
|
* NOTES
|
|
* See IUnknown_Release.
|
|
*/
|
|
ULONG WINAPI UlRelease(void *lpUnk)
|
|
{
|
|
TRACE("(%p)\n", lpUnk);
|
|
|
|
if (!lpUnk)
|
|
return 0UL;
|
|
return IUnknown_Release((LPUNKNOWN)lpUnk);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* UFromSz@4 (MAPI32.133)
|
|
*
|
|
* Read an integer from a string
|
|
*
|
|
* PARAMS
|
|
* lpszStr [I] String to read the integer from.
|
|
*
|
|
* RETURNS
|
|
* Success: The integer read from lpszStr.
|
|
* Failure: 0, if the first character in lpszStr is not 0-9.
|
|
*
|
|
* NOTES
|
|
* This function does not accept whitespace and stops at the first non-digit
|
|
* character.
|
|
*/
|
|
UINT WINAPI UFromSz(LPCSTR lpszStr)
|
|
{
|
|
ULONG ulRet = 0;
|
|
|
|
TRACE("(%s)\n", debugstr_a(lpszStr));
|
|
|
|
if (lpszStr)
|
|
{
|
|
while (*lpszStr >= '0' && *lpszStr <= '9')
|
|
{
|
|
ulRet = ulRet * 10 + (*lpszStr - '0');
|
|
lpszStr++;
|
|
}
|
|
}
|
|
return ulRet;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* OpenStreamOnFile@24 (MAPI32.147)
|
|
*
|
|
* Create a stream on a file.
|
|
*
|
|
* PARAMS
|
|
* lpAlloc [I] Memory allocation function
|
|
* lpFree [I] Memory free function
|
|
* ulFlags [I] Flags controlling the opening process
|
|
* lpszPath [I] Path of file to create stream on
|
|
* lpszPrefix [I] Prefix of the temporary file name (if ulFlags includes SOF_UNIQUEFILENAME)
|
|
* lppStream [O] Destination for created stream
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. lppStream contains the new stream object
|
|
* Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
|
|
* describing the error.
|
|
*/
|
|
HRESULT WINAPI OpenStreamOnFile(LPALLOCATEBUFFER lpAlloc, LPFREEBUFFER lpFree,
|
|
ULONG ulFlags, LPWSTR lpszPath, LPWSTR lpszPrefix,
|
|
LPSTREAM *lppStream)
|
|
{
|
|
WCHAR szBuff[MAX_PATH];
|
|
DWORD dwMode = STGM_READWRITE, dwAttributes = 0;
|
|
HRESULT hRet;
|
|
|
|
TRACE("(%p,%p,0x%08x,%s,%s,%p)\n", lpAlloc, lpFree, ulFlags,
|
|
debugstr_a((LPSTR)lpszPath), debugstr_a((LPSTR)lpszPrefix), lppStream);
|
|
|
|
if (mapiFunctions.OpenStreamOnFile)
|
|
return mapiFunctions.OpenStreamOnFile(lpAlloc, lpFree, ulFlags, lpszPath, lpszPrefix, lppStream);
|
|
|
|
if (lppStream)
|
|
*lppStream = NULL;
|
|
|
|
if (ulFlags & SOF_UNIQUEFILENAME)
|
|
{
|
|
FIXME("Should generate a temporary name\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (!lpszPath || !lppStream)
|
|
return E_INVALIDARG;
|
|
|
|
/* FIXME: Should probably munge mode and attributes, and should handle
|
|
* Unicode arguments (I assume MAPI_UNICODE is set in ulFlags if
|
|
* we are being passed Unicode strings; MSDN doesn't say).
|
|
* This implementation is just enough for Outlook97 to start.
|
|
*/
|
|
MultiByteToWideChar(CP_ACP, 0, (LPSTR)lpszPath, -1, szBuff, MAX_PATH);
|
|
hRet = SHCreateStreamOnFileEx(szBuff, dwMode, dwAttributes, TRUE,
|
|
NULL, lppStream);
|
|
return hRet;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* UlFromSzHex@4 (MAPI32.155)
|
|
*
|
|
* Read an integer from a hexadecimal string.
|
|
*
|
|
* PARAMS
|
|
* lpSzHex [I] String containing the hexadecimal number to read
|
|
*
|
|
* RETURNS
|
|
* Success: The number represented by lpszHex.
|
|
* Failure: 0, if lpszHex does not contain a hex string.
|
|
*
|
|
* NOTES
|
|
* This function does not accept whitespace and stops at the first non-hex
|
|
* character.
|
|
*/
|
|
ULONG WINAPI UlFromSzHex(LPCWSTR lpszHex)
|
|
{
|
|
LPCSTR lpStr = (LPCSTR)lpszHex;
|
|
ULONG ulRet = 0;
|
|
|
|
TRACE("(%s)\n", debugstr_a(lpStr));
|
|
|
|
while (*lpStr)
|
|
{
|
|
if (lpStr[0] < '0' || lpStr[0] > 'f' || digitsToHex[lpStr[0] - '0'] == 0xff ||
|
|
lpStr[1] < '0' || lpStr[1] > 'f' || digitsToHex[lpStr[1] - '0'] == 0xff)
|
|
break;
|
|
|
|
ulRet = ulRet * 16 + ((digitsToHex[lpStr[0] - '0'] << 4) | digitsToHex[lpStr[1] - '0']);
|
|
lpStr += 2;
|
|
}
|
|
return ulRet;
|
|
}
|
|
|
|
/************************************************************************
|
|
* FBadEntryList@4 (MAPI32.190)
|
|
*
|
|
* Determine is an entry list is invalid.
|
|
*
|
|
* PARAMS
|
|
* lpEntryList [I] List to check
|
|
*
|
|
* RETURNS
|
|
* TRUE, if lpEntryList is invalid,
|
|
* FALSE, otherwise.
|
|
*/
|
|
BOOL WINAPI FBadEntryList(LPENTRYLIST lpEntryList)
|
|
{
|
|
ULONG i;
|
|
|
|
if (IsBadReadPtr(lpEntryList, sizeof(*lpEntryList)) ||
|
|
IsBadReadPtr(lpEntryList->lpbin,
|
|
lpEntryList->cValues * sizeof(*lpEntryList->lpbin)))
|
|
return TRUE;
|
|
|
|
for (i = 0; i < lpEntryList->cValues; i++)
|
|
if(IsBadReadPtr(lpEntryList->lpbin[i].lpb, lpEntryList->lpbin[i].cb))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* CbOfEncoded@4 (MAPI32.207)
|
|
*
|
|
* Return the length of an encoded string.
|
|
*
|
|
* PARAMS
|
|
* lpSzEnc [I] Encoded string to get the length of.
|
|
*
|
|
* RETURNS
|
|
* The length of the encoded string in bytes.
|
|
*/
|
|
ULONG WINAPI CbOfEncoded(LPCSTR lpszEnc)
|
|
{
|
|
ULONG ulRet = 0;
|
|
|
|
TRACE("(%s)\n", debugstr_a(lpszEnc));
|
|
|
|
if (lpszEnc)
|
|
ulRet = (((strlen(lpszEnc) | 3) >> 2) + 1) * 3;
|
|
return ulRet;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* cmc_query_configuration (MAPI32.235)
|
|
*
|
|
* Retrieves the configuration information for the installed CMC
|
|
*
|
|
* PARAMS
|
|
* session [I] MAPI session handle
|
|
* item [I] Enumerated variable that identifies which
|
|
* configuration information is being requested
|
|
* reference [O] Buffer where configuration information is written
|
|
* config_extensions[I/O] Path of file to create stream on
|
|
*
|
|
* RETURNS
|
|
* A CMD define
|
|
*/
|
|
CMC_return_code WINAPI cmc_query_configuration(
|
|
CMC_session_id session,
|
|
CMC_enum item,
|
|
CMC_buffer reference,
|
|
CMC_extension *config_extensions)
|
|
{
|
|
FIXME("stub\n");
|
|
return CMC_E_NOT_SUPPORTED;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* FGetComponentPath (MAPI32.254)
|
|
* FGetComponentPath@20 (MAPI32.255)
|
|
*
|
|
* Return the installed component path, usually to the private mapi32.dll.
|
|
*
|
|
* PARAMS
|
|
* component [I] Component ID
|
|
* qualifier [I] Application LCID
|
|
* dll_path [O] returned component path
|
|
* dll_path_length [I] component path length
|
|
* install [I] install mode
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE.
|
|
* Failure: FALSE.
|
|
*
|
|
* NOTES
|
|
* Previously documented in Q229700 "How to locate the correct path
|
|
* to the Mapisvc.inf file in Microsoft Outlook".
|
|
*/
|
|
BOOL WINAPI FGetComponentPath(LPCSTR component, LPCSTR qualifier, LPSTR dll_path,
|
|
DWORD dll_path_length, BOOL install)
|
|
{
|
|
BOOL ret = FALSE;
|
|
HMODULE hmsi;
|
|
|
|
TRACE("%s %s %p %u %d\n", component, qualifier, dll_path, dll_path_length, install);
|
|
|
|
if (mapiFunctions.FGetComponentPath)
|
|
return mapiFunctions.FGetComponentPath(component, qualifier, dll_path, dll_path_length, install);
|
|
|
|
dll_path[0] = 0;
|
|
|
|
hmsi = LoadLibraryA("msi.dll");
|
|
if (hmsi)
|
|
{
|
|
UINT (WINAPI *pMsiProvideQualifiedComponentA)(LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD);
|
|
|
|
pMsiProvideQualifiedComponentA = (void *)GetProcAddress(hmsi, "MsiProvideQualifiedComponentA");
|
|
if (pMsiProvideQualifiedComponentA)
|
|
{
|
|
static const char * const fmt[] = { "%d\\NT", "%d\\95", "%d" };
|
|
char lcid_ver[20];
|
|
UINT i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fmt); i++)
|
|
{
|
|
/* FIXME: what's the correct behaviour here? */
|
|
if (!qualifier || qualifier == lcid_ver)
|
|
{
|
|
sprintf(lcid_ver, fmt[i], GetUserDefaultUILanguage());
|
|
qualifier = lcid_ver;
|
|
}
|
|
|
|
if (pMsiProvideQualifiedComponentA(component, qualifier,
|
|
install ? INSTALLMODE_DEFAULT : INSTALLMODE_EXISTING,
|
|
dll_path, &dll_path_length) == ERROR_SUCCESS)
|
|
{
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (qualifier != lcid_ver) break;
|
|
}
|
|
}
|
|
FreeLibrary(hmsi);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* HrQueryAllRows (MAPI32.75)
|
|
*/
|
|
HRESULT WINAPI HrQueryAllRows(LPMAPITABLE lpTable, LPSPropTagArray lpPropTags,
|
|
LPSRestriction lpRestriction, LPSSortOrderSet lpSortOrderSet,
|
|
LONG crowsMax, LPSRowSet *lppRows)
|
|
{
|
|
if (mapiFunctions.HrQueryAllRows)
|
|
return mapiFunctions.HrQueryAllRows(lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
|
|
|
|
FIXME("(%p, %p, %p, %p, %d, %p): stub\n", lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
|
|
*lppRows = NULL;
|
|
return MAPI_E_CALL_FAILED;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* WrapCompressedRTFStream (MAPI32.186)
|
|
*/
|
|
HRESULT WINAPI WrapCompressedRTFStream(LPSTREAM compressed, ULONG flags, LPSTREAM *uncompressed)
|
|
{
|
|
if (mapiFunctions.WrapCompressedRTFStream)
|
|
return mapiFunctions.WrapCompressedRTFStream(compressed, flags, uncompressed);
|
|
|
|
FIXME("(%p, 0x%08x, %p): stub\n", compressed, flags, uncompressed);
|
|
return MAPI_E_NO_SUPPORT;
|
|
}
|
|
|
|
static HMODULE mapi_provider;
|
|
static HMODULE mapi_ex_provider;
|
|
|
|
/**************************************************************************
|
|
* load_mapi_provider
|
|
*
|
|
* Attempts to load a MAPI provider from the specified registry key.
|
|
*
|
|
* Returns a handle to the loaded module in `mapi_provider' if successful.
|
|
*/
|
|
static void load_mapi_provider(HKEY hkeyMail, LPCWSTR valueName, HMODULE *mapi_provider)
|
|
{
|
|
static const WCHAR mapi32_dll[] = {'m','a','p','i','3','2','.','d','l','l',0 };
|
|
|
|
DWORD dwType, dwLen = 0;
|
|
LPWSTR dllPath;
|
|
|
|
/* Check if we have a value set for DLLPath */
|
|
if ((RegQueryValueExW(hkeyMail, valueName, NULL, &dwType, NULL, &dwLen) == ERROR_SUCCESS) &&
|
|
((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ)) && (dwLen > 0))
|
|
{
|
|
dllPath = HeapAlloc(GetProcessHeap(), 0, dwLen);
|
|
|
|
if (dllPath)
|
|
{
|
|
RegQueryValueExW(hkeyMail, valueName, NULL, NULL, (LPBYTE)dllPath, &dwLen);
|
|
|
|
/* Check that this value doesn't refer to mapi32.dll (eg, as Outlook does) */
|
|
if (lstrcmpiW(dllPath, mapi32_dll) != 0)
|
|
{
|
|
if (dwType == REG_EXPAND_SZ)
|
|
{
|
|
DWORD dwExpandLen;
|
|
LPWSTR dllPathExpanded;
|
|
|
|
/* Expand the path if necessary */
|
|
dwExpandLen = ExpandEnvironmentStringsW(dllPath, NULL, 0);
|
|
dllPathExpanded = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwExpandLen + 1);
|
|
|
|
if (dllPathExpanded)
|
|
{
|
|
ExpandEnvironmentStringsW(dllPath, dllPathExpanded, dwExpandLen + 1);
|
|
|
|
HeapFree(GetProcessHeap(), 0, dllPath);
|
|
dllPath = dllPathExpanded;
|
|
}
|
|
}
|
|
|
|
/* Load the DLL */
|
|
TRACE("loading %s\n", debugstr_w(dllPath));
|
|
*mapi_provider = LoadLibraryW(dllPath);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, dllPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* load_mapi_providers
|
|
*
|
|
* Scans the registry for MAPI providers and attempts to load a Simple and
|
|
* Extended MAPI library.
|
|
*
|
|
* Returns TRUE if at least one library loaded, FALSE otherwise.
|
|
*/
|
|
void load_mapi_providers(void)
|
|
{
|
|
static const WCHAR regkey_mail[] = {
|
|
'S','o','f','t','w','a','r','e','\\','C','l','i','e','n','t','s','\\',
|
|
'M','a','i','l',0 };
|
|
|
|
static const WCHAR regkey_dllpath[] = {'D','L','L','P','a','t','h',0 };
|
|
static const WCHAR regkey_dllpath_ex[] = {'D','L','L','P','a','t','h','E','x',0 };
|
|
static const WCHAR regkey_backslash[] = { '\\', 0 };
|
|
|
|
HKEY hkeyMail;
|
|
DWORD dwType, dwLen = 0;
|
|
LPWSTR appName = NULL, appKey = NULL;
|
|
|
|
TRACE("()\n");
|
|
|
|
/* Open the Mail key */
|
|
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, regkey_mail, 0, KEY_READ, &hkeyMail) != ERROR_SUCCESS)
|
|
return;
|
|
|
|
/* Check if we have a default value set, and the length of it */
|
|
if ((RegQueryValueExW(hkeyMail, NULL, NULL, &dwType, NULL, &dwLen) != ERROR_SUCCESS) ||
|
|
!((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ)) || (dwLen == 0))
|
|
goto cleanUp;
|
|
|
|
appName = HeapAlloc(GetProcessHeap(), 0, dwLen);
|
|
|
|
if (!appName)
|
|
goto cleanUp;
|
|
|
|
/* Get the value, and get the path to the app key */
|
|
RegQueryValueExW(hkeyMail, NULL, NULL, NULL, (LPBYTE)appName, &dwLen);
|
|
|
|
TRACE("appName: %s\n", debugstr_w(appName));
|
|
|
|
appKey = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(regkey_mail) +
|
|
lstrlenW(regkey_backslash) + lstrlenW(appName) + 1));
|
|
|
|
if (!appKey)
|
|
goto cleanUp;
|
|
|
|
lstrcpyW(appKey, regkey_mail);
|
|
lstrcatW(appKey, regkey_backslash);
|
|
lstrcatW(appKey, appName);
|
|
|
|
RegCloseKey(hkeyMail);
|
|
|
|
TRACE("appKey: %s\n", debugstr_w(appKey));
|
|
|
|
/* Open the app's key */
|
|
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, appKey, 0, KEY_READ, &hkeyMail) != ERROR_SUCCESS)
|
|
goto cleanUp;
|
|
|
|
/* Try to load the providers */
|
|
load_mapi_provider(hkeyMail, regkey_dllpath, &mapi_provider);
|
|
load_mapi_provider(hkeyMail, regkey_dllpath_ex, &mapi_ex_provider);
|
|
|
|
/* Now try to load our function pointers */
|
|
ZeroMemory(&mapiFunctions, sizeof(mapiFunctions));
|
|
|
|
/* Simple MAPI functions */
|
|
if (mapi_provider)
|
|
{
|
|
mapiFunctions.MAPIAddress = (void*) GetProcAddress(mapi_provider, "MAPIAddress");
|
|
mapiFunctions.MAPIDeleteMail = (void*) GetProcAddress(mapi_provider, "MAPIDeleteMail");
|
|
mapiFunctions.MAPIDetails = (void*) GetProcAddress(mapi_provider, "MAPIDetails");
|
|
mapiFunctions.MAPIFindNext = (void*) GetProcAddress(mapi_provider, "MAPIFindNext");
|
|
mapiFunctions.MAPILogoff = (void*) GetProcAddress(mapi_provider, "MAPILogoff");
|
|
mapiFunctions.MAPILogon = (void*) GetProcAddress(mapi_provider, "MAPILogon");
|
|
mapiFunctions.MAPIReadMail = (void*) GetProcAddress(mapi_provider, "MAPIReadMail");
|
|
mapiFunctions.MAPIResolveName = (void*) GetProcAddress(mapi_provider, "MAPIResolveName");
|
|
mapiFunctions.MAPISaveMail = (void*) GetProcAddress(mapi_provider, "MAPISaveMail");
|
|
mapiFunctions.MAPISendDocuments = (void*) GetProcAddress(mapi_provider, "MAPISendDocuments");
|
|
mapiFunctions.MAPISendMail = (void*) GetProcAddress(mapi_provider, "MAPISendMail");
|
|
mapiFunctions.MAPISendMailW = (void*) GetProcAddress(mapi_provider, "MAPISendMailW");
|
|
}
|
|
|
|
/* Extended MAPI functions */
|
|
if (mapi_ex_provider)
|
|
{
|
|
mapiFunctions.MAPIInitialize = (void*) GetProcAddress(mapi_ex_provider, "MAPIInitialize");
|
|
mapiFunctions.MAPILogonEx = (void*) GetProcAddress(mapi_ex_provider, "MAPILogonEx");
|
|
mapiFunctions.MAPIUninitialize = (void*) GetProcAddress(mapi_ex_provider, "MAPIUninitialize");
|
|
|
|
mapiFunctions.DeinitMapiUtil = (void*) GetProcAddress(mapi_ex_provider, "DeinitMapiUtil@0");
|
|
mapiFunctions.DllCanUnloadNow = (void*) GetProcAddress(mapi_ex_provider, "DllCanUnloadNow");
|
|
mapiFunctions.DllGetClassObject = (void*) GetProcAddress(mapi_ex_provider, "DllGetClassObject");
|
|
mapiFunctions.FGetComponentPath = (void*) GetProcAddress(mapi_ex_provider, "FGetComponentPath");
|
|
mapiFunctions.HrThisThreadAdviseSink = (void*) GetProcAddress(mapi_ex_provider, "HrThisThreadAdviseSink@8");
|
|
mapiFunctions.HrQueryAllRows = (void*) GetProcAddress(mapi_ex_provider, "HrQueryAllRows@24");
|
|
mapiFunctions.MAPIAdminProfiles = (void*) GetProcAddress(mapi_ex_provider, "MAPIAdminProfiles");
|
|
mapiFunctions.MAPIAllocateBuffer = (void*) GetProcAddress(mapi_ex_provider, "MAPIAllocateBuffer");
|
|
mapiFunctions.MAPIAllocateMore = (void*) GetProcAddress(mapi_ex_provider, "MAPIAllocateMore");
|
|
mapiFunctions.MAPIFreeBuffer = (void*) GetProcAddress(mapi_ex_provider, "MAPIFreeBuffer");
|
|
mapiFunctions.MAPIGetDefaultMalloc = (void*) GetProcAddress(mapi_ex_provider, "MAPIGetDefaultMalloc@0");
|
|
mapiFunctions.MAPIOpenLocalFormContainer = (void *) GetProcAddress(mapi_ex_provider, "MAPIOpenLocalFormContainer");
|
|
mapiFunctions.OpenStreamOnFile = (void*) GetProcAddress(mapi_ex_provider, "OpenStreamOnFile@24");
|
|
mapiFunctions.ScInitMapiUtil = (void*) GetProcAddress(mapi_ex_provider, "ScInitMapiUtil@4");
|
|
mapiFunctions.WrapCompressedRTFStream = (void*) GetProcAddress(mapi_ex_provider, "WrapCompressedRTFStream@12");
|
|
}
|
|
|
|
cleanUp:
|
|
RegCloseKey(hkeyMail);
|
|
HeapFree(GetProcessHeap(), 0, appKey);
|
|
HeapFree(GetProcessHeap(), 0, appName);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* unload_mapi_providers
|
|
*
|
|
* Unloads any loaded MAPI libraries.
|
|
*/
|
|
void unload_mapi_providers(void)
|
|
{
|
|
TRACE("()\n");
|
|
|
|
FreeLibrary(mapi_provider);
|
|
FreeLibrary(mapi_ex_provider);
|
|
}
|