971 lines
24 KiB
C
971 lines
24 KiB
C
/***********************************************************************
|
|
*
|
|
* WRAP.C
|
|
*
|
|
* Sample Address Book Wrap object
|
|
* This file contains the code for implementing the Sample AB
|
|
* WRAP object.
|
|
*
|
|
* This file contains methods with "default" actions for objects which
|
|
* expose IUnknown and/or IMAPIProp. These "default" actions are to call
|
|
* the appropriate method of a "wrapped" object that is a member of this
|
|
* object. Various methods in this file are used throughout this sample
|
|
* provider and are especially useful with the objects that implement template
|
|
* ids (see TID.C and OOTID.C).
|
|
*
|
|
* Copyright 1992, 1993, 1994 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
***********************************************************************/
|
|
|
|
#include "faxab.h"
|
|
|
|
/*********************************************************************
|
|
*
|
|
* The actual Wrapped IMAPIProp methods
|
|
*
|
|
*/
|
|
|
|
STDMETHODIMP
|
|
WRAP_QueryInterface( LPWRAP lpWRAP,
|
|
REFIID lpiid,
|
|
LPVOID * lppNewObj
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
return ResultFromScode(E_INVALIDARG);
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, QueryInterface)+SIZEOF(WRAP_QueryInterface_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
return ResultFromScode(E_INVALIDARG);
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_QueryInterface != lpWRAP->lpVtbl->QueryInterface)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
return ResultFromScode(E_INVALIDARG);
|
|
}
|
|
|
|
EnterCriticalSection(&lpWRAP->cs);
|
|
/* Call the internal prop interface */
|
|
|
|
hr = lpWRAP->lpPropData->lpVtbl->QueryInterface( lpWRAP->lpPropData,
|
|
lpiid,
|
|
lppNewObj
|
|
);
|
|
|
|
/* If this object is successful in QI'ing and it returns exactly the
|
|
* same object, then I need to AddRef my own "wrapper" object so that
|
|
* my release code works correctly AND replace the *lppNewObj with the
|
|
* "wrapper" object.
|
|
*/
|
|
if (!HR_FAILED(hr) && (lpWRAP->lpPropData == *lppNewObj))
|
|
{
|
|
++lpWRAP->lcInit;
|
|
*lppNewObj = lpWRAP;
|
|
}
|
|
|
|
LeaveCriticalSection(&lpWRAP->cs);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) WRAP_AddRef(LPWRAP lpWRAP)
|
|
{
|
|
ULONG ulRet;
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, AddRef)+SIZEOF(WRAP_AddRef_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_AddRef != lpWRAP->lpVtbl->AddRef)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
EnterCriticalSection(&lpWRAP->cs);
|
|
++lpWRAP->lcInit;
|
|
|
|
/* Call the internal prop interface */
|
|
|
|
ulRet = lpWRAP->lpPropData->lpVtbl->AddRef(lpWRAP->lpPropData);
|
|
|
|
LeaveCriticalSection(&lpWRAP->cs);
|
|
|
|
return ulRet;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) WRAP_Release(LPWRAP lpWRAP)
|
|
{
|
|
long lcInit;
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, Release)+SIZEOF(WRAP_Release_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_Release != lpWRAP->lpVtbl->Release)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
|
|
EnterCriticalSection(&lpWRAP->cs);
|
|
|
|
/*
|
|
* Release the imapiprop object
|
|
*/
|
|
|
|
lpWRAP->lpPropData->lpVtbl->Release(
|
|
lpWRAP->lpPropData);
|
|
|
|
lcInit = --lpWRAP->lcInit;
|
|
|
|
LeaveCriticalSection(&lpWRAP->cs);
|
|
|
|
if (lcInit == 0)
|
|
{
|
|
|
|
/*
|
|
* Get rid of my critical section
|
|
*/
|
|
DeleteCriticalSection(&lpWRAP->cs);
|
|
|
|
/*
|
|
* Set the Jump table to NULL. This way the client will find out
|
|
* real fast if it's calling a method on a released object. That is,
|
|
* the client will crash. Hopefully, this will happen during the
|
|
* development stage of the client.
|
|
*/
|
|
|
|
lpWRAP->lpVtbl = NULL;
|
|
|
|
/*
|
|
* Need to free the object
|
|
*/
|
|
|
|
lpWRAP->lpFreeBuff(lpWRAP);
|
|
return 0;
|
|
}
|
|
|
|
return lcInit;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_GetLastError( LPWRAP lpWRAP,
|
|
HRESULT hError,
|
|
ULONG ulFlags,
|
|
LPMAPIERROR FAR * lppMapiError
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, GetLastError)+SIZEOF(WRAP_GetLastError_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_GetLastError != lpWRAP->lpVtbl->GetLastError)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
if ( ulFlags & ~MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_UNKNOWN_FLAGS );
|
|
return hResult ;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( ulFlags & MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
|
|
return hResult;
|
|
}
|
|
#endif
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->GetLastError( lpWRAP->lpPropData,
|
|
hError,
|
|
ulFlags,
|
|
lppMapiError
|
|
);
|
|
}
|
|
|
|
/* IProperty */
|
|
|
|
STDMETHODIMP
|
|
WRAP_SaveChanges( LPWRAP lpWRAP,
|
|
ULONG ulFlags
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, SaveChanges)+SIZEOF(WRAP_SaveChanges_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_SaveChanges != lpWRAP->lpVtbl->SaveChanges)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
hResult = lpWRAP->lpPropData->lpVtbl->SaveChanges( lpWRAP->lpPropData,
|
|
ulFlags
|
|
);
|
|
|
|
return hResult;
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_GetProps( LPWRAP lpWRAP,
|
|
LPSPropTagArray lpPropTagArray,
|
|
ULONG ulFlags,
|
|
ULONG * lpcValues,
|
|
LPSPropValue * lppPropArray
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, GetProps)+SIZEOF(WRAP_GetProps_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_GetProps != lpWRAP->lpVtbl->GetProps)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
if ( ulFlags & ~(MAPI_UNICODE) )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_UNKNOWN_FLAGS );
|
|
|
|
return hResult;
|
|
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( ulFlags & MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
|
|
return hResult;
|
|
}
|
|
#endif
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->GetProps( lpWRAP->lpPropData,
|
|
lpPropTagArray,
|
|
ulFlags,
|
|
lpcValues,
|
|
lppPropArray
|
|
);
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_GetPropList( LPWRAP lpWRAP,
|
|
ULONG ulFlags,
|
|
LPSPropTagArray * lppPropTagArray
|
|
)
|
|
{
|
|
HRESULT hResult = hrSuccess;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, GetPropList)+SIZEOF(WRAP_GetPropList_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_GetPropList != lpWRAP->lpVtbl->GetPropList)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
if ( ulFlags & ~(MAPI_UNICODE) )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_UNKNOWN_FLAGS );
|
|
|
|
return hResult;
|
|
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( ulFlags & MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
|
|
return hResult;
|
|
}
|
|
#endif
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->GetPropList( lpWRAP->lpPropData,
|
|
ulFlags,
|
|
lppPropTagArray
|
|
);
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_OpenProperty( LPWRAP lpWRAP,
|
|
ULONG ulPropTag,
|
|
LPCIID lpiid,
|
|
ULONG ulInterfaceOptions,
|
|
ULONG ulFlags,
|
|
LPUNKNOWN * lppUnk
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, OpenProperty)+SIZEOF(WRAP_OpenProperty_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_OpenProperty != lpWRAP->lpVtbl->OpenProperty)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
|
|
if ( ulInterfaceOptions & ~MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_UNKNOWN_FLAGS );
|
|
return hResult;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( ulInterfaceOptions & MAPI_UNICODE )
|
|
{
|
|
hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
|
|
return hResult;
|
|
}
|
|
#endif
|
|
|
|
hResult = lpWRAP->lpPropData->lpVtbl->OpenProperty( lpWRAP->lpPropData,
|
|
ulPropTag,
|
|
lpiid,
|
|
ulInterfaceOptions,
|
|
ulFlags,
|
|
lppUnk
|
|
);
|
|
|
|
return hResult;
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_SetProps( LPWRAP lpWRAP,
|
|
ULONG cValues,
|
|
LPSPropValue lpPropArray,
|
|
LPSPropProblemArray * lppProblems
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, SetProps)+SIZEOF(WRAP_SetProps_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_SetProps != lpWRAP->lpVtbl->SetProps)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->SetProps( lpWRAP->lpPropData,
|
|
cValues,
|
|
lpPropArray,
|
|
lppProblems
|
|
);
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_DeleteProps( LPWRAP lpWRAP,
|
|
LPSPropTagArray lpPropTagArray,
|
|
LPSPropProblemArray * lppProblems
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, DeleteProps)+SIZEOF(WRAP_DeleteProps_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_DeleteProps != lpWRAP->lpVtbl->DeleteProps)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->DeleteProps( lpWRAP->lpPropData,
|
|
lpPropTagArray,
|
|
lppProblems
|
|
);
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_CopyTo( LPWRAP lpWRAP,
|
|
ULONG ciidExclude,
|
|
LPCIID rgiidExclude,
|
|
LPSPropTagArray lpExcludeProps,
|
|
ULONG ulUIParam,
|
|
LPMAPIPROGRESS lpProgress,
|
|
LPCIID lpInterface,
|
|
LPVOID lpDestObj,
|
|
ULONG ulFlags,
|
|
LPSPropProblemArray FAR * lppProblems
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, CopyTo)+SIZEOF(WRAP_CopyTo_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_CopyTo != lpWRAP->lpVtbl->CopyTo)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->CopyTo( lpWRAP->lpPropData,
|
|
ciidExclude,
|
|
rgiidExclude,
|
|
lpExcludeProps,
|
|
ulUIParam,
|
|
lpProgress,
|
|
lpInterface,
|
|
lpDestObj,
|
|
ulFlags,
|
|
lppProblems
|
|
);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_CopyProps( LPWRAP lpWRAP,
|
|
LPSPropTagArray lpIncludeProps,
|
|
ULONG ulUIParam,
|
|
LPMAPIPROGRESS lpProgress,
|
|
LPCIID lpInterface,
|
|
LPVOID lpDestObj,
|
|
ULONG ulFlags,
|
|
LPSPropProblemArray FAR * lppProblems
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, CopyProps)+SIZEOF(WRAP_CopyProps_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_CopyProps != lpWRAP->lpVtbl->CopyProps)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->CopyProps( lpWRAP->lpPropData,
|
|
lpIncludeProps,
|
|
ulUIParam,
|
|
lpProgress,
|
|
lpInterface,
|
|
lpDestObj,
|
|
ulFlags,
|
|
lppProblems
|
|
);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_GetNamesFromIDs( LPWRAP lpWRAP,
|
|
LPSPropTagArray * lppPropTags,
|
|
LPGUID lpPropSetGuid,
|
|
ULONG ulFlags,
|
|
ULONG * lpcPropNames,
|
|
LPMAPINAMEID ** lpppPropNames
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, GetNamesFromIDs)+SIZEOF(WRAP_GetNamesFromIDs_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_GetNamesFromIDs != lpWRAP->lpVtbl->GetNamesFromIDs)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->GetNamesFromIDs( lpWRAP->lpPropData,
|
|
lppPropTags,
|
|
lpPropSetGuid,
|
|
ulFlags,
|
|
lpcPropNames,
|
|
lpppPropNames
|
|
);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WRAP_GetIDsFromNames( LPWRAP lpWRAP,
|
|
ULONG cPropNames,
|
|
LPMAPINAMEID * lppPropNames,
|
|
ULONG ulFlags,
|
|
LPSPropTagArray * lppPropTags
|
|
)
|
|
{
|
|
HRESULT hResult;
|
|
|
|
/*
|
|
* Check to see if it has a lpVtbl object member
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP, offsetof(WRAP, lpVtbl)+SIZEOF(WRAP_Vtbl *)))
|
|
{
|
|
/*
|
|
* No jump table found
|
|
*/
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see that the Vtbl is large enough to include this method
|
|
*/
|
|
if (IsBadReadPtr(lpWRAP->lpVtbl,
|
|
offsetof(WRAP_Vtbl, GetIDsFromNames)+SIZEOF(WRAP_GetIDsFromNames_METHOD *)))
|
|
{
|
|
/*
|
|
* Jump table not derived from IUnknown
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* Check to see if the method is the same
|
|
*/
|
|
if (WRAP_GetIDsFromNames != lpWRAP->lpVtbl->GetIDsFromNames)
|
|
{
|
|
/*
|
|
* Wrong object - the object passed doesn't have this
|
|
* method.
|
|
*/
|
|
|
|
hResult = ResultFromScode(E_INVALIDARG);
|
|
|
|
return hResult;
|
|
}
|
|
|
|
return lpWRAP->lpPropData->lpVtbl->GetIDsFromNames( lpWRAP->lpPropData,
|
|
cPropNames,
|
|
lppPropNames,
|
|
ulFlags,
|
|
lppPropTags
|
|
);
|
|
}
|