util.c File Reference

#include <stdarg.h>
#include <stdio.h>
#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"

Include dependency graph for util.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Typedefs
typedef LPVOID *	LPMAPIALLOCBUFFER

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mapi)
SCODE WINAPI	ScInitMapiUtil (ULONG ulReserved)
VOID WINAPI	DeinitMapiUtil (void)
SCODE WINAPI	MAPIAllocateBuffer (ULONG cbSize, LPVOID *lppBuffer)
SCODE WINAPI	MAPIAllocateMore (ULONG cbSize, LPVOID lpOrig, LPVOID *lppBuffer)
ULONG WINAPI	MAPIFreeBuffer (LPVOID lpBuffer)
HRESULT WINAPI	WrapProgress (PVOID unk1, PVOID unk2, PVOID unk3, PVOID unk4, PVOID unk5)
HRESULT WINAPI	HrDispatchNotifications (ULONG flags)
HRESULT WINAPI	HrThisThreadAdviseSink (LPMAPIADVISESINK lpSink, LPMAPIADVISESINK *lppNewSink)
BOOL WINAPI	FBinFromHex (LPWSTR lpszHex, LPBYTE lpOut)
void WINAPI	HexFromBin (LPBYTE lpHex, int iCount, LPWSTR lpszOut)
VOID WINAPI	SwapPlong (PULONG lpData, ULONG ulLen)
VOID WINAPI	SwapPword (PUSHORT lpData, ULONG ulLen)
ULONG WINAPI	MNLS_lstrlenW (LPCWSTR lpszStr)
INT WINAPI	MNLS_lstrcmpW (LPCWSTR lpszLeft, LPCWSTR lpszRight)
ULONG WINAPI	MNLS_lstrcpyW (LPWSTR lpszDest, LPCWSTR lpszSrc)
INT WINAPI	MNLS_CompareStringW (DWORD dwCp, LPCWSTR lpszLeft, LPCWSTR lpszRight)
BOOL WINAPI	FEqualNames (LPMAPINAMEID lpName1, LPMAPINAMEID lpName2)
BOOL WINAPI	IsBadBoundedStringPtr (LPCSTR lpszStr, ULONG ulLen)
LONGLONG WINAPI	MAPI32_FtAddFt (FILETIME ftLeft, FILETIME ftRight)
LONGLONG WINAPI	MAPI32_FtSubFt (FILETIME ftLeft, FILETIME ftRight)
LONGLONG WINAPI	MAPI32_FtMulDw (DWORD dwLeft, FILETIME ftRight)
LONGLONG WINAPI	MAPI32_FtMulDwDw (DWORD dwLeft, DWORD dwRight)
LONGLONG WINAPI	MAPI32_FtNegFt (FILETIME ft)
ULONG WINAPI	UlAddRef (void *lpUnk)
ULONG WINAPI	UlRelease (void *lpUnk)
UINT WINAPI	UFromSz (LPCSTR lpszStr)
HRESULT WINAPI	OpenStreamOnFile (LPALLOCATEBUFFER lpAlloc, LPFREEBUFFER lpFree, ULONG ulFlags, LPWSTR lpszPath, LPWSTR lpszPrefix, LPSTREAM *lppStream)
ULONG WINAPI	UlFromSzHex (LPCWSTR lpszHex)
BOOL WINAPI	FBadEntryList (LPENTRYLIST lpEntryList)
ULONG WINAPI	CbOfEncoded (LPCSTR lpszEnc)
CMC_return_code WINAPI	cmc_query_configuration (CMC_session_id session, CMC_enum item, CMC_buffer reference, CMC_extension *config_extensions)
BOOL WINAPI	FGetComponentPath (LPCSTR component, LPCSTR qualifier, LPSTR dll_path, DWORD dll_path_length, BOOL install)
HRESULT WINAPI	HrQueryAllRows (LPMAPITABLE lpTable, LPSPropTagArray lpPropTags, LPSRestriction lpRestriction, LPSSortOrderSet lpSortOrderSet, LONG crowsMax, LPSRowSet *lppRows)
HRESULT WINAPI	WrapCompressedRTFStream (LPSTREAM compressed, ULONG flags, LPSTREAM *uncompressed)
static void	load_mapi_provider (HKEY hkeyMail, LPCWSTR valueName, HMODULE *mapi_provider)
void	load_mapi_providers (void)
void	unload_mapi_providers (void)

Variables
static const BYTE	digitsToHex []
MAPI_FUNCTIONS	mapiFunctions
static HMODULE	mapi_provider
static HMODULE	mapi_ex_provider

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file util.c.

Typedef Documentation

LPMAPIALLOCBUFFER

typedef LPVOID* LPMAPIALLOCBUFFER

Definition at line 101 of file util.c.

Function Documentation

CbOfEncoded()

ULONG WINAPI CbOfEncoded

(

LPCSTR

lpszEnc

)

Definition at line 823 of file util.c.

{
    ULONG ulRet = 0;
 
    TRACE("(%s)\n", debugstr_a(lpszEnc));
 
    if (lpszEnc)
        ulRet = (((strlen(lpszEnc) | 3) >> 2) + 1) * 3;
    return ulRet;
}

cmc_query_configuration()

CMC_return_code WINAPI cmc_query_configuration	(	CMC_session_id	session,
		CMC_enum	item,
		CMC_buffer	reference,
		CMC_extension *	config_extensions
	)

Definition at line 849 of file util.c.

{
    FIXME("stub\n");
    return CMC_E_NOT_SUPPORTED;
}

DeinitMapiUtil()

VOID WINAPI DeinitMapiUtil

(

void

)

Definition at line 93 of file util.c.

{
    if (mapiFunctions.DeinitMapiUtil)
        mapiFunctions.DeinitMapiUtil();
    else
        FIXME("()stub!\n");
}

FBadEntryList()

BOOL WINAPI FBadEntryList

(

LPENTRYLIST

lpEntryList

)

Definition at line 796 of file util.c.

{
    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;
}

Referenced by FBadProp().

FBinFromHex()

BOOL WINAPI FBinFromHex	(	LPWSTR	lpszHex,
		LPBYTE	lpOut
	)

Definition at line 298 of file util.c.

{
    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;
}

FEqualNames()

BOOL WINAPI FEqualNames	(	LPMAPINAMEID	lpName1,
		LPMAPINAMEID	lpName2
	)

Definition at line 486 of file util.c.

{
    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;
}

FGetComponentPath()

BOOL WINAPI FGetComponentPath	(	LPCSTR	component,
		LPCSTR	qualifier,
		LPSTR	dll_path,
		DWORD	dll_path_length,
		BOOL	install
	)

Definition at line 880 of file util.c.

{
    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;
}

HexFromBin()

void WINAPI HexFromBin	(	LPBYTE	lpHex,
		int	iCount,
		LPWSTR	lpszOut
	)

Definition at line 336 of file util.c.

{
    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';
}

HrDispatchNotifications()

HRESULT WINAPI HrDispatchNotifications

(

ULONG

flags

)

Definition at line 243 of file util.c.

{
    FIXME("(%08x)\n", flags);
    return S_OK;
}

HrQueryAllRows()

HRESULT WINAPI HrQueryAllRows	(	LPMAPITABLE	lpTable,
		LPSPropTagArray	lpPropTags,
		LPSRestriction	lpRestriction,
		LPSSortOrderSet	lpSortOrderSet,
		LONG	crowsMax,
		LPSRowSet *	lppRows
	)

Definition at line 933 of file util.c.

{
    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;
}

HrThisThreadAdviseSink()

HRESULT WINAPI HrThisThreadAdviseSink	(	LPMAPIADVISESINK	lpSink,
		LPMAPIADVISESINK *	lppNewSink
	)

Definition at line 262 of file util.c.

{
    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;
}

IsBadBoundedStringPtr()

BOOL WINAPI IsBadBoundedStringPtr	(	LPCSTR	lpszStr,
		ULONG	ulLen
	)

Definition at line 514 of file util.c.

{
    if (!lpszStr || IsBadStringPtrA(lpszStr, -1) || strlen(lpszStr) >= ulLen)
        return TRUE;
    return FALSE;
}

load_mapi_provider()

static void load_mapi_provider ( HKEY  hkeyMail, LPCWSTR  valueName, HMODULE *  mapi_provider  )

static

Definition at line 967 of file util.c.

{
    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);
        }
    }
}

Referenced by load_mapi_providers().

load_mapi_providers()

void load_mapi_providers

(

void

)

Definition at line 1023 of file util.c.

{
    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);
}

Referenced by DllMain().

MAPI32_FtAddFt()

LONGLONG WINAPI MAPI32_FtAddFt	(	FILETIME	ftLeft,
		FILETIME	ftRight
	)

Definition at line 533 of file util.c.

{
    LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
 
    return *pl + *pr;
}

MAPI32_FtMulDw()

LONGLONG WINAPI MAPI32_FtMulDw	(	DWORD	dwLeft,
		FILETIME	ftRight
	)

Definition at line 571 of file util.c.

{
    LONGLONG *pr = (LONGLONG*)&ftRight;
 
    return (LONGLONG)dwLeft * (*pr);
}

MAPI32_FtMulDwDw()

LONGLONG WINAPI MAPI32_FtMulDwDw	(	DWORD	dwLeft,
		DWORD	dwRight
	)

Definition at line 590 of file util.c.

{
    return (LONGLONG)dwLeft * (LONGLONG)dwRight;
}

MAPI32_FtNegFt()

LONGLONG WINAPI MAPI32_FtNegFt

(

FILETIME

ft

)

Definition at line 606 of file util.c.

{
    LONGLONG *p = (LONGLONG*)&ft;
 
    return - *p;
}

MAPI32_FtSubFt()

LONGLONG WINAPI MAPI32_FtSubFt	(	FILETIME	ftLeft,
		FILETIME	ftRight
	)

Definition at line 552 of file util.c.

{
    LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
 
    return *pr - *pl;
}

MAPIAllocateBuffer()

SCODE WINAPI MAPIAllocateBuffer	(	ULONG	cbSize,
		LPVOID *	lppBuffer
	)

Definition at line 125 of file util.c.

{
    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()

SCODE WINAPI MAPIAllocateMore	(	ULONG	cbSize,
		LPVOID	lpOrig,
		LPVOID *	lppBuffer
	)

Definition at line 168 of file util.c.

{
    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()

ULONG WINAPI MAPIFreeBuffer

(

LPVOID

lpBuffer

)

Definition at line 207 of file util.c.

{
    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;
}

MNLS_CompareStringW()

INT WINAPI MNLS_CompareStringW	(	DWORD	dwCp,
		LPCWSTR	lpszLeft,
		LPCWSTR	lpszRight
	)

Definition at line 464 of file util.c.

{
    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;
}

MNLS_lstrcmpW()

INT WINAPI MNLS_lstrcmpW	(	LPCWSTR	lpszLeft,
		LPCWSTR	lpszRight
	)

Definition at line 422 of file util.c.

{
    TRACE("(%s,%s)\n", debugstr_w(lpszLeft), debugstr_w(lpszRight));
    return lstrcmpW(lpszLeft, lpszRight);
}

Referenced by MNLS_CompareStringW().

MNLS_lstrcpyW()

ULONG WINAPI MNLS_lstrcpyW	(	LPWSTR	lpszDest,
		LPCWSTR	lpszSrc
	)

Definition at line 440 of file util.c.

{
    ULONG len;
 
    TRACE("(%p,%s)\n", lpszDest, debugstr_w(lpszSrc));
    len = (lstrlenW(lpszSrc) + 1) * sizeof(WCHAR);
    memcpy(lpszDest, lpszSrc, len);
    return len;
}

MNLS_lstrlenW()

ULONG WINAPI MNLS_lstrlenW

(

LPCWSTR

lpszStr

)

Definition at line 403 of file util.c.

{
    TRACE("(%s)\n", debugstr_w(lpszStr));
    return lstrlenW(lpszStr);
}

OpenStreamOnFile()

HRESULT WINAPI OpenStreamOnFile	(	LPALLOCATEBUFFER	lpAlloc,
		LPFREEBUFFER	lpFree,
		ULONG	ulFlags,
		LPWSTR	lpszPath,
		LPWSTR	lpszPrefix,
		LPSTREAM *	lppStream
	)

Definition at line 712 of file util.c.

{
    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;
}

ScInitMapiUtil()

SCODE WINAPI ScInitMapiUtil

(

ULONG

ulReserved

)

Definition at line 67 of file util.c.

{
    if (mapiFunctions.ScInitMapiUtil)
        return mapiFunctions.ScInitMapiUtil(ulReserved);
 
    FIXME("(0x%08x)stub!\n", ulReserved);
    if (ulReserved)
        return MAPI_E_INVALID_PARAMETER;
    return S_OK;
}

SwapPlong()

VOID WINAPI SwapPlong	(	PULONG	lpData,
		ULONG	ulLen
	)

Definition at line 364 of file util.c.

{
    ULONG i;
 
    for (i = 0; i < ulLen; i++)
        lpData[i] = RtlUlongByteSwap(lpData[i]);
}

SwapPword()

VOID WINAPI SwapPword	(	PUSHORT	lpData,
		ULONG	ulLen
	)

Definition at line 384 of file util.c.

{
    ULONG i;
 
    for (i = 0; i < ulLen; i++)
        lpData[i] = RtlUshortByteSwap(lpData[i]);
}

UFromSz()

UINT WINAPI UFromSz

(

LPCSTR

lpszStr

)

Definition at line 677 of file util.c.

{
    ULONG ulRet = 0;
 
    TRACE("(%s)\n", debugstr_a(lpszStr));
 
    if (lpszStr)
    {
        while (*lpszStr >= '0' && *lpszStr <= '9')
        {
            ulRet = ulRet * 10 + (*lpszStr - '0');
            lpszStr++;
        }
    }
    return ulRet;
}

UlAddRef()

ULONG WINAPI UlAddRef

(

void *

lpUnk

)

Definition at line 627 of file util.c.

{
    TRACE("(%p)\n", lpUnk);
 
    if (!lpUnk)
        return 0UL;
    return IUnknown_AddRef((LPUNKNOWN)lpUnk);
}

UlFromSzHex()

ULONG WINAPI UlFromSzHex

(

LPCWSTR

lpszHex

)

Definition at line 765 of file util.c.

{
    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;
}

UlRelease()

ULONG WINAPI UlRelease

(

void *

lpUnk

)

Definition at line 652 of file util.c.

{
    TRACE("(%p)\n", lpUnk);
 
    if (!lpUnk)
        return 0UL;
    return IUnknown_Release((LPUNKNOWN)lpUnk);
}

unload_mapi_providers()

void unload_mapi_providers

(

void

)

Definition at line 1135 of file util.c.

{
    TRACE("()\n");
 
    FreeLibrary(mapi_provider);
    FreeLibrary(mapi_ex_provider);
}

Referenced by DllMain().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mapi

)

WrapCompressedRTFStream()

HRESULT WINAPI WrapCompressedRTFStream	(	LPSTREAM	compressed,
		ULONG	flags,
		LPSTREAM *	uncompressed
	)

Definition at line 948 of file util.c.

{
    if (mapiFunctions.WrapCompressedRTFStream)
        return mapiFunctions.WrapCompressedRTFStream(compressed, flags, uncompressed);
 
    FIXME("(%p, 0x%08x, %p): stub\n", compressed, flags, uncompressed);
    return MAPI_E_NO_SUPPORT;
}

WrapProgress()

HRESULT WINAPI WrapProgress	(	PVOID	unk1,
		PVOID	unk2,
		PVOID	unk3,
		PVOID	unk4,
		PVOID	unk5
	)

Definition at line 234 of file util.c.

{
    /* Native does not implement this function */
    return MAPI_E_NO_SUPPORT;
}

Variable Documentation

digitsToHex

const BYTE digitsToHex[]

static

Initial value:

= {
  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 }

Definition at line 43 of file util.c.

Referenced by FBinFromHex(), and UlFromSzHex().

mapi_ex_provider

HMODULE mapi_ex_provider

static

Definition at line 958 of file util.c.

Referenced by load_mapi_providers(), and unload_mapi_providers().

mapi_provider

HMODULE mapi_provider

static

Definition at line 957 of file util.c.

Referenced by load_mapi_provider(), load_mapi_providers(), and unload_mapi_providers().

mapiFunctions

MAPI_FUNCTIONS mapiFunctions

Definition at line 49 of file util.c.

Referenced by DeinitMapiUtil(), DllCanUnloadNow(), DllGetClassObject(), FGetComponentPath(), HrQueryAllRows(), HrThisThreadAdviseSink(), load_mapi_providers(), MAPIAddress(), MAPIAdminProfiles(), MAPIAllocateBuffer(), MAPIAllocateMore(), MAPIDeleteMail(), MAPIDetails(), MAPIFindNext(), MAPIFreeBuffer(), MAPIGetDefaultMalloc(), MAPIInitialize(), MAPILogoff(), MAPILogon(), MAPILogonEx(), MAPIOpenLocalFormContainer(), MAPIReadMail(), MAPIResolveName(), MAPISaveMail(), MAPISendDocuments(), MAPISendMail(), MAPISendMailW(), MAPIUninitialize(), OpenStreamOnFile(), ScInitMapiUtil(), and WrapCompressedRTFStream().