Windows编程

开发平台：
Visual C++

ROOT.C：源码内容
							/***********************************************************************
 *
 *  ROOT.C
 *
 *
 *  Sample AB Root object
 *      - This file contains the code for implementing the Sample AB
 *      root object and the hierarchy table.
 *
 *  The Root container object is returned via an ABPOpenEntry() with a
 *  0-sized entryid.  It only has a limited set of properties available on
 *  it.  The most useful method on it is GetHierarchyTable() which returns
 *  the root hierarchy associated with this provider.
 *
 *  The hierarchy table has only a single row in it.  The row represents the
 *  single .SAB file which this provider browses.  If a provider wanted to
 *  browse many different lists, it would have multiple rows.
 *
 *  The following routines are implemented in this file:
 *
 *
 *    To implement the Root container object:
 *
 *      HrNewROOT
 *      SetErrorSz
 *      ROOT_QueryInterface
 *      ROOT_AddRef
 *      ROOT_Release
 *      ROOT_GetLastError
 *      ROOT_SaveChanges
 *      ROOT_OpenProperty
 *      ROOT_GetContentsTable
 *      ROOT_GetHierarchyTable
 *      ROOT_OpenEntry
 *      ROOT_CreateEntry
 *      ROOT_CopyEntries
 *      ROOT_DeleteEntries
 *      ROOT_ResolveNames
 *
 *  Copyright 1992-1995 Microsoft Corporation.  All Rights Reserved.
 *
 ***********************************************************************/
#include "abp.h"
#include "sampabp.rh"
/*
 *  The structure behind the 'this' pointer
 */
typedef struct _ROOT
{
    const ROOT_Vtbl FAR *   lpVtbl;
    SAB_Wrapped;
    
} ROOT, *LPROOT;
/*
 *  Root vtbl is filled in here
 */
static const ROOT_Vtbl vtblROOT =
{
    ROOT_QueryInterface,
    ROOT_AddRef,
    ROOT_Release,
    ROOT_GetLastError,
    ROOT_SaveChanges,
    (ROOT_GetProps_METHOD *) WRAP_GetProps,
    (ROOT_GetPropList_METHOD *) WRAP_GetPropList,
    ROOT_OpenProperty,
    (ROOT_SetProps_METHOD *) WRAP_SetProps,
    (ROOT_DeleteProps_METHOD *) WRAP_DeleteProps,
    (ROOT_CopyTo_METHOD *) WRAP_CopyTo,
    (ROOT_CopyProps_METHOD *) WRAP_CopyProps,
    (ROOT_GetNamesFromIDs_METHOD *) WRAP_GetNamesFromIDs,
    (ROOT_GetIDsFromNames_METHOD *) WRAP_GetIDsFromNames,
    ROOT_GetContentsTable,
    ROOT_GetHierarchyTable,
    ROOT_OpenEntry,
    ROOT_SetSearchCriteria,
    ROOT_GetSearchCriteria,
    ROOT_CreateEntry,
    ROOT_CopyEntries,
    ROOT_DeleteEntries,
    ROOT_ResolveNames
};
/*
 *  Default properties in this object
 */
enum {  ivalPR_DISPLAY_TYPE = 0,
        ivalPR_OBJECT_TYPE,
        ivalPR_ENTRYID,
        ivalPR_RECORD_KEY,
        ivalPR_SEARCH_KEY,
        ivalPR_DISPLAY_NAME_A,
        ivalPR_CONTAINER_FLAGS,
        cvalMax };
/*
 -  HrNewROOT
 -
 *  Creates a new Root Container object.  This object is created
 *  when an lpABLogon::OpenEntry() is called with a 0-sized entryid.
 *
 *
 */
HRESULT
HrNewROOT(LPABCONT *        lppROOT,
          ULONG *           lpulObjType,
          LPABLOGON         lpABPLogon,
          LPCIID            lpInterface,
          HINSTANCE         hLibrary,
          LPALLOCATEBUFFER  lpAllocBuff,
          LPALLOCATEMORE    lpAllocMore,
          LPFREEBUFFER      lpFreeBuff,
          LPMALLOC          lpMalloc )
{
    LPROOT lpROOT = NULL;
    SCODE scode;
    LPPROPDATA lpPropData = NULL;
    SPropValue spv[cvalMax];
    HRESULT hResult;
    char szDisplayName[MAX_ROOT_NAME];
    LPSTR pszDisplayName = (LPSTR) szDisplayName;
    SCODE sc;
    DIR_ENTRYID eidRoot =   {   {0, 0, 0, 0},
                                MUIDABSAMPLE,
                                SAMP_VERSION,
                                SAMP_DIRECTORY };
    /*  Do I support this interface?? */
    if (lpInterface)
    {
        if (memcmp(lpInterface, &IID_IUnknown, sizeof(IID)) &&
            memcmp(lpInterface, &IID_IMAPIProp, sizeof(IID)) &&
            memcmp(lpInterface, &IID_IMAPIContainer, sizeof(IID)) &&
            memcmp(lpInterface, &IID_IABContainer, sizeof(IID)))
        {
            DebugTraceSc(HrNewROOT, MAPI_E_INTERFACE_NOT_SUPPORTED);
            return ResultFromScode(MAPI_E_INTERFACE_NOT_SUPPORTED);
        }
    }
    /*
     *  Allocate space for the ROOT structure
     */
    scode = lpAllocBuff (sizeof(ROOT), (LPVOID *) &lpROOT);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto err;
    }
    lpROOT->lpVtbl = &vtblROOT;
    lpROOT->lcInit = 1;
    lpROOT->hResult = hrSuccess;
    lpROOT->idsLastError = 0;
    lpROOT->hLibrary = hLibrary;
    lpROOT->lpAllocBuff = lpAllocBuff;
    lpROOT->lpAllocMore = lpAllocMore;
    lpROOT->lpFreeBuff = lpFreeBuff;
    lpROOT->lpMalloc = lpMalloc;
    lpROOT->lpABLogon = lpABPLogon;
    /*
     *  Create a property storage object
     */
    scode = CreateIProp((LPIID) &IID_IMAPIPropData,
        lpAllocBuff,
        lpAllocMore,
        lpFreeBuff,
        lpMalloc,
        &lpPropData);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto err;
    }
    /*
     *  Set up initial set of properties associated with this
     *  container.
     */
    spv[ivalPR_DISPLAY_TYPE].ulPropTag = PR_DISPLAY_TYPE;
    spv[ivalPR_DISPLAY_TYPE].Value.l = 0;           /* undefined for now */
    spv[ivalPR_OBJECT_TYPE].ulPropTag = PR_OBJECT_TYPE;
    spv[ivalPR_OBJECT_TYPE].Value.l = MAPI_ABCONT;
    spv[ivalPR_ENTRYID].ulPropTag = PR_ENTRYID;
    spv[ivalPR_ENTRYID].Value.bin.cb = sizeof(DIR_ENTRYID);
    spv[ivalPR_ENTRYID].Value.bin.lpb = (LPBYTE) &eidRoot;
    spv[ivalPR_RECORD_KEY].ulPropTag = PR_RECORD_KEY;
    spv[ivalPR_RECORD_KEY].Value.bin.cb = sizeof(DIR_ENTRYID);
    spv[ivalPR_RECORD_KEY].Value.bin.lpb = (LPBYTE) &eidRoot;
    spv[ivalPR_SEARCH_KEY].ulPropTag = PR_SEARCH_KEY;
    spv[ivalPR_SEARCH_KEY].Value.bin.cb = sizeof(DIR_ENTRYID);
    spv[ivalPR_SEARCH_KEY].Value.bin.lpb = (LPBYTE) &eidRoot;
    sc = ScLoadString(  IDS_ROOT_NAME,
                        MAX_ROOT_NAME,
                        NULL,
                        hLibrary,
                        (LPSTR *) &pszDisplayName);
    if (FAILED(sc))
    {
        hResult = ResultFromScode(sc);
        goto out;
    }
    spv[ivalPR_DISPLAY_NAME_A].ulPropTag = PR_DISPLAY_NAME_A;
    spv[ivalPR_DISPLAY_NAME_A].Value.lpszA = szDisplayName;
    spv[ivalPR_CONTAINER_FLAGS].ulPropTag = PR_CONTAINER_FLAGS;
    spv[ivalPR_CONTAINER_FLAGS].Value.l = AB_SUBCONTAINERS;
    /*
     *   Set the default properties
     */
    hResult = lpPropData->lpVtbl->SetProps(lpPropData,
        cvalMax,
        spv,
        NULL);
    if (HR_FAILED(hResult))
    {
        goto err;
    }
    /*
     *  The whole object is set READONLY thus eliminating the need to
     *  set access rights for the individual properties.
     */
    (void) lpPropData->lpVtbl->HrSetObjAccess(lpPropData, IPROP_READONLY);
    lpROOT->lpPropData = (LPMAPIPROP) lpPropData;
    InitializeCriticalSection(&lpROOT->cs);
    /*  We must AddRef the lpABPLogon object since we will be using it
     */
    lpABPLogon->lpVtbl->AddRef(lpABPLogon);
    *lpulObjType = MAPI_ABCONT;
    *lppROOT = (LPVOID) lpROOT;
out:
    DebugTraceResult(HrNewROOT, hResult);
    return hResult;
err:
    /*
     *  free the root object
     */
    lpFreeBuff (lpROOT);
    /*
     *  free the prop data
     */
    if (lpPropData)
        lpPropData->lpVtbl->Release(lpPropData);
    goto out;
    
}
/*************************************************************************
 *
 *
 -  SetErrorIDS
 -
 *  Handles remembering the last error string associated with an object.
 *  This string is retrieved by the method GetLastError()
 *
 *
 */
VOID
SetErrorIDS(LPVOID lpObject, HRESULT hResult, UINT ids)
{
    ((LPROOT) lpObject)->hResult = hResult;
    ((LPROOT) lpObject)->idsLastError = ids;
}
/*
 -  ROOT_QueryInterface
 -
 *  Supports QI'ing to IUnknown, IMAPIProp, IMAPIContainer, and IABContainer.
 *
 */
STDMETHODIMP
ROOT_QueryInterface(LPROOT lpROOT,
                    REFIID lpiid,
                    LPVOID FAR * lppNewObj)
{
    HRESULT hr = hrSuccess;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        hr = ResultFromScode(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, QueryInterface)+sizeof(ROOT_QueryInterface_METHOD *)))
    {
        /*
         *  Jump table not derived from IUnknown
         */
        hr = ResultFromScode(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_QueryInterface != lpROOT->lpVtbl->QueryInterface)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hr = ResultFromScode(E_INVALIDARG);
        goto out;
    }
    Validate_IUnknown_QueryInterface(lpROOT, lpiid, lppNewObj);
    /*  See if the requested interface is one of ours */
    if (memcmp(lpiid, &IID_IUnknown, sizeof(IID)) &&
        memcmp(lpiid, &IID_IMAPIProp, sizeof(IID)) &&
        memcmp(lpiid, &IID_IMAPIContainer, sizeof(IID)) &&
        memcmp(lpiid, &IID_IABContainer, sizeof(IID)))
    {
        *lppNewObj = NULL;      /* OLE requires zeroing [out] parameter */
        hr = ResultFromScode(E_NOINTERFACE);
        goto out;
    }
    /*  We'll do this one. Bump the usage count and return a new pointer. */
    EnterCriticalSection(&lpROOT->cs);
    ++lpROOT->lcInit;
    LeaveCriticalSection(&lpROOT->cs);
    
    *lppNewObj = lpROOT;
out:
    DebugTraceResult(ROOT_QueryInterface, hr);
    return hr;
}
/**************************************************
 *
 -  ROOT_AddRef
 -
 *      Increment lcInit
 *
 */
STDMETHODIMP_(ULONG) ROOT_AddRef(LPROOT lpROOT)
{
    LONG lcInit;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        return 1;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, AddRef)+sizeof(ROOT_AddRef_METHOD *)))
    {
        /*
         *  Jump table not derived from IUnknown
         */
        return 1;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_AddRef != lpROOT->lpVtbl->AddRef)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        return 1;
    }
    Validate_IUnknown_AddRef(lpROOT);
    EnterCriticalSection(&lpROOT->cs);
    lcInit = ++lpROOT->lcInit;
    LeaveCriticalSection(&lpROOT->cs);
    return lcInit;
}
/**************************************************
 *
 -  ROOT_Release
 -
 *      Decrement lcInit.
 *      When lcInit == 0, free up the lpROOT structure
 *
 */
STDMETHODIMP_(ULONG) ROOT_Release(LPROOT lpROOT)
{
    LONG lcInit;
    
    /*
     *  Check to see if it can be a ROOT object
     */
    if (IsBadReadPtr(lpROOT, sizeof(ROOT)))
    {
        /*
         *  Not large enough
         */
        return 1;
    }
    /*
     *  Check to see that it's ROOTs vtbl
     */
    if (lpROOT->lpVtbl != &vtblROOT)
    {
        /*
         *  Not my jump table
         */
        return 1;
    }
    Validate_IUnknown_Release(lpROOT);
    EnterCriticalSection(&lpROOT->cs);
    lcInit = --lpROOT->lcInit;
    LeaveCriticalSection(&lpROOT->cs);
    if (lcInit == 0)
    {
        /*
         *  Delete our critical section
         */
        DeleteCriticalSection(&lpROOT->cs);
        /*
         *  Set the vtbl 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.
         */
        lpROOT->lpVtbl = NULL;
        /*
         *  free the property storage object
         */
        if (lpROOT->lpPropData)
            lpROOT->lpPropData->lpVtbl->Release(lpROOT->lpPropData);
        /*  
         *  Release our reference to the ABLogon object.
         */
        if (lpROOT->lpABLogon)
        {
            lpROOT->lpABLogon->lpVtbl->Release(lpROOT->lpABLogon);
            lpROOT->lpABLogon = NULL;
        }
        /*
         *  Free the object
         */
        lpROOT->lpFreeBuff(lpROOT);
        return 0;
    }
    return lcInit;
}
/*
 -  ROOT_GetLastError
 -
 *      Returns a string associated with the last hResult
 *  returned by the ROOT object.
 *
 */
STDMETHODIMP
ROOT_GetLastError(  LPROOT lpROOT,
                    HRESULT hError,
                    ULONG ulFlags,
                    LPMAPIERROR FAR * lppMapiError )
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    LPSTR   lpszMessage = NULL;
    /*
     *  Validate parameters
     */
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
        offsetof(ROOT_Vtbl, GetLastError)+sizeof(ROOT_GetLastError_METHOD *)))
    {
        /*
         *  Jump table not derived from IUnknown
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_GetLastError != lpROOT->lpVtbl->GetLastError)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = ResultFromScode(E_INVALIDARG);
        DebugTraceResult(ROOT_GetLastError, hResult);
        return hResult;
    }
    Validate_IMAPIProp_GetLastError(lpROOT, hError, ulFlags, lppMapiError);
    /*                              
     *  NOTE:  We don't handle UNICODE yet.  Everything is
     *  assumed to be working in 8-bit char mode.
     */
    if (ulFlags & MAPI_UNICODE)
    {
        hResult = ResultFromScode(MAPI_E_BAD_CHARWIDTH);
        DebugTraceResult(ROOT_GetLastError, hResult);
        return hResult;
    }
    EnterCriticalSection(&lpROOT->cs);
    
    if ((hError != hrSuccess) && (hError == lpROOT->hResult))
    {
        scode = lpROOT->lpAllocBuff( sizeof( MAPIERROR ), lppMapiError );
        if ( FAILED( scode ) )      
        {
            hResult = ResultFromScode(scode);
            goto ret;
        }
        
        ZeroMemory( *lppMapiError, sizeof( MAPIERROR ) );
        
        (*lppMapiError)->ulVersion = MAPI_ERROR_VERSION;
        /*
         *  Get the MAPI Allocated string associated with the last error
         */
        scode = ScLoadString(lpROOT->idsLastError,
                             MAX_ERROR_STRING_LENGTH,
                             lpROOT->lpAllocBuff,
                             lpROOT->hLibrary,
                             &lpszMessage);
        if ( FAILED( scode) )                            
        {
            hResult = ResultFromScode(scode);
            goto ret;
        }
        
        scode = lpROOT->lpAllocMore( lstrlenA( lpszMessage ) + 1, *lppMapiError, 
            &(*lppMapiError)->lpszError );
        if ( FAILED( scode ) )      
        {
            hResult = ResultFromScode(scode);
            goto ret;
        }
        
        lstrcpyA( (*lppMapiError)->lpszError, lpszMessage );
        
        
    } else
    {
        *lppMapiError = NULL;
    }
ret:
    if ( hResult )
    {
        lpROOT->lpFreeBuff( *lppMapiError );
        *lppMapiError = NULL;
    }
    
    lpROOT->lpFreeBuff( lpszMessage );
    LeaveCriticalSection(&lpROOT->cs);
    return hResult;
}
/*
 -  ROOT_SaveChanges
 -
 *  Can't save changes on this object.
 *
 *
 */
STDMETHODIMP
ROOT_SaveChanges(LPROOT lpROOT, ULONG ulFlags)
{
    HRESULT hResult;
    ROOT_ValidateObject(ROOT_SaveChanges, lpROOT);
    Validate_IMAPIProp_SaveChanges(lpROOT, ulFlags);
    hResult = ResultFromScode(E_ACCESSDENIED);
    DebugTraceResult(ROOT_SaveChanges, hResult);
    return hResult;
}
/*
 -  ROOT_OpenProperty
 -
 *
 *  For this object I only need to support opening the hierarchy table.
 *
 */
STDMETHODIMP
ROOT_OpenProperty(  LPROOT lpROOT,
                    ULONG ulPropTag,
                    LPCIID lpiid,
                    ULONG ulInterfaceOptions,
                    ULONG ulFlags,
                    LPUNKNOWN * lppUnk)
{
    HRESULT hResult;
    ROOT_ValidateObject(ROOT_OpenProperty, lpROOT);
    
    Validate_IMAPIProp_OpenProperty(lpROOT, ulPropTag, lpiid,
                            ulInterfaceOptions, ulFlags, lppUnk);
    
    if (ulFlags & MAPI_CREATE)
    {
        hResult = ResultFromScode(E_ACCESSDENIED);
        goto out;       
    }
        
    if (ulInterfaceOptions & ~MAPI_UNICODE)
    {
        /*
         *  Only UNICODE flag should be set for any of the objects that might
         *  be returned from this object.
         */
        
        hResult = ResultFromScode(MAPI_E_UNKNOWN_FLAGS);
        goto out;
    }
    
    if ( ulInterfaceOptions & MAPI_UNICODE )
    {
        hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
        goto out;
    }
    switch (ulPropTag)
    {
        case PR_CONTAINER_HIERARCHY:
        {
            /*
             *  Check to see if they're expecting a IMAPITable object
             */
            if (memcmp(lpiid, &IID_IMAPITable, sizeof(IID)))
            {
                hResult = ResultFromScode(MAPI_E_INTERFACE_NOT_SUPPORTED);
                goto out;
            }
            hResult = ROOT_GetHierarchyTable(lpROOT, 0, (LPMAPITABLE *) lppUnk);
            goto out;
        }
        default:
            break;
    }
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_OpenProperty, hResult);
    return hResult;
}
/*************************************************************************
 *
 *
 -  ROOT_GetContentsTable
 -
 *  There are no contents in the root
 *
 *
 *
 */
STDMETHODIMP
ROOT_GetContentsTable(  LPROOT lpROOT,
                        ULONG ulFlags,
                        LPMAPITABLE * lppTable)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
        offsetof(ROOT_Vtbl, GetContentsTable)+sizeof(ROOT_GetContentsTable_METHOD *)))
    {
        /*
         *  Jump table not derived from IUnknown
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_GetContentsTable != lpROOT->lpVtbl->GetContentsTable)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = ResultFromScode(E_INVALIDARG);
        DebugTraceResult(ROOT_GetContentsTable, hResult);
        return hResult;
    }
    Validate_IMAPIContainer_GetContentsTable(lpROOT, ulFlags, lppTable);
    
    if ( ulFlags & MAPI_UNICODE )
    {
        hResult = ResultFromScode( MAPI_E_BAD_CHARWIDTH );
        goto out;
    }
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_GetContentsTable, hResult);
    return hResult;
}
/*
 -  ROOT_GetHierarchyTable
 -
 *  Returns the table with just one entry in it.
 *
 *
 *
 */
STDMETHODIMP
ROOT_GetHierarchyTable( LPROOT lpROOT,
                        ULONG ulFlags,
                        LPMAPITABLE * lppTable)
{
    HRESULT hResult = hrSuccess;
    ROOT_ValidateObject(ROOT_GetHierarchyTable, lpROOT);
    Validate_IMAPIContainer_GetHierarchyTable(lpROOT, ulFlags, lppTable);
    
    /*
     *  Since we only have one item in our hierarchy table, CONVENIENT_DEPTH
     *  is equivalent to any other depth level (>1).  So, just ignore the
     *  flag.  MAPI_DEFERRED_ERROR is fine.  We don't ever defer errors.
     */
    /*
     *  Create a View Table for the hierarchy.
     */
    hResult = HrBuildRootHier(lpROOT->lpABLogon, lppTable);
    DebugTraceResult(ROOT_GetHierarchyTable, hResult);
    return hResult;
}
/*
 -  ROOT_OpenEntry
 -
 *  Check parameters and use our logon object's OpenEntry method.
 */
STDMETHODIMP
ROOT_OpenEntry(LPROOT lpROOT,
    ULONG cbEntryID,
    LPENTRYID lpEntryID,
    LPCIID lpInterface,
    ULONG ulFlags,
    ULONG * lpulObjType,
    LPUNKNOWN * lppUnk)
{
    HRESULT hResult;
    
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  No vtbl found
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
        offsetof(ROOT_Vtbl, OpenEntry)+sizeof(ROOT_OpenEntry_METHOD *)))
    {
        /*
         *  vtbl cannot hold this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that it's the correct method
     */
    if (ROOT_OpenEntry != lpROOT->lpVtbl->OpenEntry)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);
        goto out;
    }
    Validate_IABLogon_OpenEntry(lpROOT, cbEntryID, lpEntryID, lpInterface,
                                    ulFlags, lpulObjType, lppUnk);
    hResult = lpROOT->lpABLogon->lpVtbl->OpenEntry(lpROOT->lpABLogon,
        cbEntryID,
        lpEntryID,
        lpInterface,
        ulFlags,
        lpulObjType,
        lppUnk);
    
out:
    DebugTraceResult(ROOT_OpenEntry, hResult);
    return hResult;
}
/*
 -  ROOT_SetSearchCriteria
 -
 *
 *  Not implemented for this object
 */
STDMETHODIMP
ROOT_SetSearchCriteria(LPROOT lpROOT,
    LPSRestriction lpRestriction,
    LPENTRYLIST lpContainerList,
    ULONG ulSearchFlags)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
        offsetof(ROOT_Vtbl, SetSearchCriteria)+sizeof(ROOT_SetSearchCriteria_METHOD *)))
    {
        /*
         *  vtbl not large enough to support this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that it's the correct method
     */
    if (ROOT_SetSearchCriteria != lpROOT->lpVtbl->SetSearchCriteria)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);
        goto out;
    }
    Validate_IMAPIContainer_SetSearchCriteria(lpROOT, lpRestriction,
                                        lpContainerList, ulSearchFlags);
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_SetSearchCriteria, hResult);
    return hResult;
}
/*
 -  ROOT_GetSearchCriteria
 -
 *
 *  Not implemented for this object
 *
 */
STDMETHODIMP
ROOT_GetSearchCriteria(LPROOT lpROOT,
    ULONG ulFlags,
    LPSRestriction FAR * lppRestriction,
    LPENTRYLIST FAR * lppContainerList,
    ULONG FAR * lpulSearchState)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  Not large enough
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
        offsetof(ROOT_Vtbl, GetSearchCriteria)+sizeof(ROOT_GetSearchCriteria_METHOD *)))
    {
        /*
         *  Jump table not derived from IUnknown
         */
        hResult = MakeResult(E_INVALIDARG);
        return hResult;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_GetSearchCriteria != lpROOT->lpVtbl->GetSearchCriteria)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = ResultFromScode(E_INVALIDARG);
        DebugTraceResult(ROOT_GetSearchCriteria, hResult);
        return hResult;
    }
    
    Validate_IMAPIContainer_GetSearchCriteria(lpROOT, ulFlags, lppRestriction,
                                            lppContainerList, lpulSearchState);
    
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
    DebugTraceResult(ROOT_GetSearchCriteria, hResult);
    return hResult;
}
/*
 -  ROOT_CreateEntry
 -
 *  New entries cannot be created in the root
 *
 */
STDMETHODIMP
ROOT_CreateEntry(LPROOT lpROOT,
    ULONG cbEntryID,
    LPENTRYID lpEntryID,
    ULONG ulCreateFlags,
    LPMAPIPROP FAR * lppMAPIPropEntry)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  No vtbl found
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, CreateEntry)+sizeof(ROOT_CreateEntry_METHOD *)))
    {
        /*
         *  vtbl not large enough to hold this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_CreateEntry != lpROOT->lpVtbl->CreateEntry)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    Validate_IABContainer_CreateEntry(lpROOT, cbEntryID, lpEntryID,
                                ulCreateFlags, lppMAPIPropEntry );
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_CreateEntry, hResult);
    return hResult;
}
/*
 -  ROOT_CopyEntries
 -
 *  Entries cannot be copied into the root
 *
 *
 *
 */
STDMETHODIMP
ROOT_CopyEntries(LPROOT lpROOT,
    LPENTRYLIST lpEntries,
    ULONG ulUIParam,
    LPMAPIPROGRESS lpProgress,
    ULONG ulFlags)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  No vtbl found
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, CopyEntries)+sizeof(ROOT_CopyEntries_METHOD *)))
    {
        /*
         *  vtbl not large enough to hold this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_CopyEntries != lpROOT->lpVtbl->CopyEntries)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    Validate_IABContainer_CopyEntries(lpROOT, lpEntries, ulUIParam,
                                        lpProgress, ulFlags);
    
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_CopyEntries, hResult);
    return hResult;
}
/*
 -  ROOT_DeleteEntries
 -
 *  Entries cannot be deleted from the root
 *
 *
 *
 */
STDMETHODIMP
ROOT_DeleteEntries(LPROOT lpROOT,
    LPENTRYLIST lpEntries,
    ULONG ulFlags)
{
    HRESULT hResult;
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  No vtbl found
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, DeleteEntries)+sizeof(ROOT_DeleteEntries_METHOD *)))
    {
        /*
         *  vtbl not large enough to hold this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_DeleteEntries != lpROOT->lpVtbl->DeleteEntries)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    Validate_IABContainer_DeleteEntries(lpROOT, lpEntries, ulFlags);
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_DeleteEntries, hResult);
    return hResult;
}
/*
 -  ROOT_ResolveNames
 -
 *  No special case handling of resolving names within this container
 *
 *
 *
 */
STDMETHODIMP
ROOT_ResolveNames(  LPROOT          lpROOT,
                    LPSPropTagArray lptagaColSet,
                    ULONG           ulFlags,
                    LPADRLIST       lpAdrList,
                    LPFlagList      lpFlagList )
{
    HRESULT hResult;
        
    /*
     *  Check to see if it has a lpVtbl object member
     */
    if (IsBadReadPtr(lpROOT, offsetof(ROOT, lpVtbl)+sizeof(ROOT_Vtbl *)))
    {
        /*
         *  No vtbl found
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see that the Vtbl is large enough to include this method
     */
    if (IsBadReadPtr(lpROOT->lpVtbl,
                     offsetof(ROOT_Vtbl, ResolveNames)+sizeof(ROOT_ResolveNames_METHOD *)))
    {
        /*
         *  vtbl not large enough to hold this method
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    /*
     *  Check to see if the method is the same
     */
    if (ROOT_ResolveNames != lpROOT->lpVtbl->ResolveNames)
    {
        /*
         *  Wrong object - the object passed doesn't have this
         *  method.
         */
        hResult = MakeResult(E_INVALIDARG);
        goto out;
    }
    CheckParameters_IABContainer_ResolveNames(lpROOT, lptagaColSet, ulFlags,
                                            lpAdrList, lpFlagList);
    
    hResult = ResultFromScode(MAPI_E_NO_SUPPORT);
out:
    DebugTraceResult(ROOT_ResolveNames, hResult);
    return hResult;
}

						