windows-xp/Source/XPSP1/NT/net/tapi/skywalker/mspbase/mspaddr.cpp

/*++

Copyright (c) 1998-1999  Microsoft Corporation

Module Name:

    mspaddr.cpp 

Abstract:

    This module contains implementation of CMSPAddress.

--*/

#include "precomp.h"
#pragma hdrstop



///////////////////////////////////////////////////////////////////////////////
//
// AllocateEventItem and FreeEventItem are MSPEVENTITEM allocation routines.
// they are be used to allocate and deallocate MSPEVENTITEM structures
//
///////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
//
//  AllocateEventItem
//
//  allocate an MSPEVENTITEM. Since the structure is of variable size, the 
//  number of extra bytes to be allocated (in addition to the size of 
//  MSPEVENTITEM) is optionally passed as the function's argument
//
//  the function returns a pointer to the newly created structure or NULL in 
//  the case of failure. the caller can then call GetLastError to get more 
//  information on the failure
//

MSPEVENTITEM *AllocateEventItem(SIZE_T nExtraBytes)
{

    LOG((MSP_TRACE, "AllocateEventItem - enter, extra bytes = 0x%p", nExtraBytes));


    //
    // if the caller passes us too big a number, fail.
    //

    if ( ( MAXULONG_PTR - sizeof(MSPEVENTITEM) )  < nExtraBytes )
    {
        SetLastError(ERROR_OUTOFMEMORY);

        LOG((MSP_ERROR, 
            "AllocateEventItem - the caller requested an unreasonably large memory block"));

        return NULL;
    }


    //
    // allocate on the process' heap. get the current process' heap handle.
    //

    HANDLE hHeapHandle = GetProcessHeap();

    if (NULL == hHeapHandle)
    {

        //
        // failed to get process's heap. nothing much we can do here.
        // this will cause a leak.
        //

        LOG((MSP_ERROR, 
            "AllocateEventItem - failed to get current process heap. LastError [%ld]", 
            GetLastError()));

        return NULL;
    }


    //
    // calculate the number of bytes to allocate
    //

    SIZE_T nTotalAllocationSize = sizeof(MSPEVENTITEM) + nExtraBytes;


    //
    // attempt to allocate memory and return result of the allocation
    //
    
    MSPEVENTITEM *pMspEventItem = 
         (MSPEVENTITEM *)HeapAlloc(hHeapHandle, 0, nTotalAllocationSize);


    if (NULL == pMspEventItem)
    {

        LOG((MSP_ERROR,
            "AllocateEventItem - failed to allocate [0x%p] bytes. Heap Handle [%p] LastError [%ld]",
            nTotalAllocationSize, hHeapHandle, GetLastError()));
    }
    else
    {

        LOG((MSP_TRACE, "AllocateEventItem - exit. pMspEventItem = [%p]", pMspEventItem));
    }

    return pMspEventItem;
}


//////////////////////////////////////////////////////////////////////////////
//
//  FreeEventItem
//
//  deallocate the MSPEVENTITEM passed as an argument. The memory must have
//  been previously allocated by AllocateEventItem.
//
//  the function eturns FALSE in case of failure. The caller can use 
//  GetLastError to get a more specific error code.
//

BOOL FreeEventItem(MSPEVENTITEM *pEventItemToBeFreed)
{

    LOG((MSP_TRACE, "FreeEventItem - enter. pEventItemToBeFreed = [%p]", 
        pEventItemToBeFreed));


    //
    // always allow freeing NULL
    //

    if (NULL == pEventItemToBeFreed)
    {

        LOG((MSP_TRACE, "FreeEventItem - finish. NULL -- nothing to do"));

        return TRUE;
    }

    //
    // the event item should have been allocated on the process' heap.
    // get the current process' heap hadle.
    //

    HANDLE hHeapHandle = GetProcessHeap();

    if (NULL == hHeapHandle)
    {

        //
        // failed to get process's heap. nothing much we can do here.
        // this will cause a leak.
        //

        LOG((MSP_ERROR, 
            "FreeEventItem - failed to get current process heap. LastError = %ld", 
            GetLastError()));

        return FALSE;
    }


    //
    // attempt to free memory and return result of the operation
    //
    
    BOOL bFreeSuccess = HeapFree( hHeapHandle, 0, pEventItemToBeFreed );

    if (bFreeSuccess)
    {
         LOG((MSP_TRACE, "FreeEventItem - exit."));
    }
    else
    {
         LOG((MSP_ERROR, 
             "FreeEventItem - failed to free. Heap Handle [%p] LastError = %ld",
             hHeapHandle, GetLastError()));
    }


    return bFreeSuccess;
}


//////////////////////////////////////////////////////////////////////////////


HRESULT CPlugTerminalClassInfo::FinalConstruct(void)
{
    LOG((MSP_TRACE, "CPlugTerminalClassInfo::FinalConstruct - enter"));

    HRESULT hr = CoCreateFreeThreadedMarshaler( GetControllingUnknown(),
                                                & m_pFTM );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::FinalConstruct - "
            "create FTM returned 0x%08x; exit", hr));

        return hr;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::FinalConstruct - exit S_OK"));

    return S_OK;

}

//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CPlugTerminalClassInfo::get_Name(
    /*[out, retval]*/ BSTR*     pName
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Name - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pName, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Name exit -"
            "pName invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrName, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Name exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pName = SysAllocString( m_bstrName );

    //
    // Validates SysAllocString
    //

    if( *pName == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Name exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Name - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_Name(
    /*[in]*/    BSTR            bstrName
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Name - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrName, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Name exit -"
            "bstrName invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrName, (UINT)-1) )
    {
        SysFreeString( m_bstrName );
        m_bstrName = NULL;
    }

    //
    // Set the new name
    //

    m_bstrName = SysAllocString( bstrName );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrName )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Name exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Name - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_Company(
    /*[out, retval]*/ BSTR*     pCompany
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Company - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pCompany, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Company exit -"
            "pCompany invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrCompany, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Company exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pCompany = SysAllocString( m_bstrCompany );

    //
    // Validates SysAllocString
    //

    if( *pCompany == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Company exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Company - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_Company(
    /*[in]*/    BSTR            bstrCompany
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Company - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrCompany, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Company exit -"
            "bstrCompany invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrCompany, (UINT)-1) )
    {
        SysFreeString( m_bstrCompany );
        m_bstrCompany = NULL;
    }

    //
    // Set the new name
    //

    m_bstrCompany = SysAllocString( bstrCompany );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrCompany )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Company exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Company - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_Version(
    /*[out, retval]*/ BSTR*     pVersion
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Version - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pVersion, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Version exit -"
            "pVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrVersion, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Version exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pVersion = SysAllocString( m_bstrVersion );

    //
    // Validates SysAllocString
    //

    if( *pVersion == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Version exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Version - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_Version(
    /*[in]*/    BSTR            bstrVersion
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Version - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrVersion, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Version exit -"
            "bstrVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrVersion, (UINT)-1) )
    {
        SysFreeString( m_bstrVersion );
        m_bstrVersion = NULL;
    }

    //
    // Set the new name
    //

    m_bstrVersion = SysAllocString( bstrVersion );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrVersion )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_Version exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_Version - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_TerminalClass(
    /*[out, retval]*/ BSTR*     pTerminalClass
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_TerminalClass - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pTerminalClass, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_TerminalClass exit -"
            "pVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrTerminalClass, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_TerminalClass exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pTerminalClass = SysAllocString( m_bstrTerminalClass );

    //
    // Validates SysAllocString
    //

    if( *pTerminalClass == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_TerminalClass exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_TerminalClass - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_TerminalClass(
    /*[in]*/    BSTR            bstrTerminalClass
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_TerminalClass - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrTerminalClass, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_TerminalClass exit -"
            "bstrTerminalClass invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Is a real CLSID?
    //

    CLSID clsid;
    HRESULT hr = CLSIDFromString(bstrTerminalClass, &clsid);
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_TerminalClass exit -"
            "bstrTerminalClass is not a CLSID, returns E_INVALIDARG"));
        return E_INVALIDARG;
    }


    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrTerminalClass, (UINT)-1) )
    {
        SysFreeString( m_bstrTerminalClass );
        m_bstrTerminalClass = NULL;
    }

    //
    // Set the new name
    //

    m_bstrTerminalClass = SysAllocString( bstrTerminalClass );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrTerminalClass )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_TerminalClass exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_TerminalClass - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_CLSID(
    /*[out, retval]*/ BSTR*     pCLSID
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_CLSID - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pCLSID, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_CLSID exit -"
            "pVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrCLSID, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_CLSID exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pCLSID = SysAllocString( m_bstrCLSID );

    //
    // Validates SysAllocString
    //

    if( *pCLSID == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_CLSID exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_CLSID - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_CLSID(
    /*[in]*/    BSTR            bstrCLSID
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_CLSID - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrCLSID, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_CLSID exit -"
            "bstrCLSID invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Is a real CLSID?
    //

    CLSID clsid;
    HRESULT hr = CLSIDFromString(bstrCLSID, &clsid);
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_CLSID exit -"
            "bstrCLSID is not a CLSID, returns E_INVALIDARG"));
        return E_INVALIDARG;
    }


    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrCLSID, (UINT)-1) )
    {
        SysFreeString( m_bstrCLSID );
        m_bstrCLSID = NULL;
    }

    //
    // Set the new name
    //

    m_bstrCLSID = SysAllocString( bstrCLSID );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrCLSID )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_CLSID exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::put_CLSID - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_Direction(
    /*[out, retval]*/ TERMINAL_DIRECTION*  pDirection
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Direction - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pDirection, sizeof(long)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_Direction exit -"
            "pDirection invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Return the name
    //

    *pDirection = m_Direction;

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_Direction - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_Direction(
    /*[in]*/    TERMINAL_DIRECTION  nDirection
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_Direction - enter"));

    //
    // Set the new name
    //

    m_Direction = nDirection;

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_Direction - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::get_MediaTypes(
    /*[out, retval]*/ long*     pMediaTypes
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_MediaTypes - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pMediaTypes, sizeof(long)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::get_MediaTypes exit -"
            "pMediaTypes invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Return the name
    //

    *pMediaTypes = m_lMediaType;

    LOG((MSP_TRACE, "CPlugTerminalClassInfo::get_MediaTypes - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalClassInfo::put_MediaTypes(
    /*[in]*/    long            nMediaTypes
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_MediaTypes - enter"));

    //
    // Set the new name
    //

    m_lMediaType = nMediaTypes;

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_MediaTypes - exit"));
    return S_OK;
}

//////////////////////////////////////////////////////////////////////////////


HRESULT CPlugTerminalSuperclassInfo::FinalConstruct(void)
{
    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::FinalConstruct - enter"));

    HRESULT hr = CoCreateFreeThreadedMarshaler( GetControllingUnknown(),
                                                & m_pFTM );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::FinalConstruct - "
            "create FTM returned 0x%08x; exit", hr));

        return hr;
    }

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::FinalConstruct - exit S_OK"));

    return S_OK;

}

//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CPlugTerminalSuperclassInfo::get_Name(
    /*[out, retval]*/ BSTR*          pName
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::get_Name - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pName, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_Name exit -"
            "pVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrName, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_Name exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pName = SysAllocString( m_bstrName );

    //
    // Validates SysAllocString
    //

    if( *pName == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_Name exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::get_Name - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CPlugTerminalSuperclassInfo::put_Name(
    /*[in]*/          BSTR            bstrName
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_Name - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrName, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::put_Name exit -"
            "bstrName invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrName, (UINT)-1) )
    {
        SysFreeString( m_bstrName );
        m_bstrName = NULL;
    }

    //
    // Set the new name
    //

    m_bstrName = SysAllocString( bstrName );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrName )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::put_Name exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_Name - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CPlugTerminalSuperclassInfo::get_CLSID(
    /*[out, retval]*/ BSTR*           pCLSID
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::get_CLSID - enter"));

    //
    // Validates argument
    //

    if( MSPB_IsBadWritePtr( pCLSID, sizeof(BSTR)) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_CLSID exit -"
            "pVersion invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Validates the name
    //

    if( IsBadStringPtr( m_bstrCLSID, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_CLSID exit -"
            "m_bstrName invalid, returns E_UNEXPECTED"));
        return E_UNEXPECTED;
    }

    //
    // Return the name
    //

    *pCLSID = SysAllocString( m_bstrCLSID );

    //
    // Validates SysAllocString
    //

    if( *pCLSID == NULL )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::get_CLSID exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::get_CLSID - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


STDMETHODIMP CPlugTerminalSuperclassInfo::put_CLSID(
    /*[in]*/         BSTR            bstrCLSID
    )
{
    //
    // Critical section
    //

    CLock lock(m_CritSect);

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_CLSID - enter"));

    //
    // Validates argument
    //

    if(IsBadStringPtr( bstrCLSID, (UINT)-1) )
    {
        LOG((MSP_ERROR, "CPlugTerminalClassInfo::put_CLSID exit -"
            "bstrCLSID invalid, returns E_POINTER"));
        return E_POINTER;
    }

    //
    // Is a real CLSID?
    //

    CLSID clsid;
    HRESULT hr = CLSIDFromString(bstrCLSID, &clsid);
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::put_CLSID exit -"
            "bstrCLSID is not a CLSID, returns E_INVALIDARG"));
        return E_INVALIDARG;
    }


    //
    // Clean-up the old name
    //

    if(!IsBadStringPtr( m_bstrCLSID, (UINT)-1) )
    {
        SysFreeString( m_bstrCLSID );
        m_bstrCLSID = NULL;
    }

    //
    // Set the new name
    //

    m_bstrCLSID = SysAllocString( bstrCLSID );

    //
    // Validates SysAllocString
    //

    if( NULL == m_bstrCLSID )
    {
        LOG((MSP_ERROR, "CPlugTerminalSuperclassInfo::put_CLSID exit -"
            "SysAllocString failed, returns E_OUTOFMEMORY"));
        return E_OUTOFMEMORY;
    }

    LOG((MSP_TRACE, "CPlugTerminalSuperclassInfo::put_CLSID - exit"));
    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////


//
// Our available static terminal types.
//

const STATIC_TERMINAL_TYPE CMSPAddress::m_saTerminalTypes[] =
{
    {
        (DWORD) TAPIMEDIATYPE_AUDIO,
        &CLSID_CWaveinClassManager,
        CAudioCaptureTerminal::CreateTerminal
    },
    {
        (DWORD) TAPIMEDIATYPE_AUDIO,
        &CLSID_CWaveOutClassManager,
        CAudioRenderTerminal::CreateTerminal
    },
    {
        (DWORD) TAPIMEDIATYPE_VIDEO,
        &CLSID_CVidCapClassManager,
        CVideoCaptureTerminal::CreateTerminal
    }
};

const DWORD CMSPAddress::m_sdwTerminalTypesCount = sizeof(m_saTerminalTypes)
                                              / sizeof (STATIC_TERMINAL_TYPE);

/////////////////////////////////////////////////////////////////////////////
// CMSPAddress
/////////////////////////////////////////////////////////////////////////////

//
// Check to see if the mediatype is non-zero and is in the mask.
// Your MSP can override this if it needs to do atypically complex
// checks on specific combinations of media types (e.g., can never
// have more than one media type on a call, can have video with audio
// but not video alone, etc.). The default implementation accepts any
// nonempty set of media types that is a subset of the set of types
// in the mask.
//

BOOL CMSPAddress::IsValidSetOfMediaTypes(DWORD dwMediaType, DWORD dwMask)
{
    return (dwMediaType != 0) && ((dwMediaType & dwMask) == dwMediaType);
}

CMSPAddress::CMSPAddress()
    : m_htEvent(NULL),
      m_fTerminalsUpToDate(FALSE),
      m_pITTerminalManager(NULL)
{
    LOG((MSP_TRACE, "CMSPAddress::CMSPAddress[%p] - enter", this));

    LOG((MSP_TRACE, "CMSPAddress::CMSPAddress - finished"));
}
      
CMSPAddress::~CMSPAddress() 
{
    LOG((MSP_TRACE, "CMSPAddress::~CMSPAddress[%p] - enter", this));


    //
    // this should have been taken care of in Shutdown,
    // but just in case shutdown was never called, do this again, since 
    // we need to make sure the thread does not have any stale entries in 
    // its pnp notification list
    // 
    // the call is likely to return error (since the object is likely to have been
    // unregisted earlier) -- so ignore return code
    //

    g_Thread.UnregisterPnpNotification(this);


    LOG((MSP_TRACE, "CMSPAddress::~CMSPAddress - finished"));
}

STDMETHODIMP CMSPAddress::Initialize(
    IN      MSP_HANDLE          htEvent
    )
/*++

Routine Description:

This method is called by TAPI3 when this MSP is first created. The method 
initiailzes data members and creates the terminal manager. It also tells
the global thread object to Start().

Arguments:

htEvent
    Event the MSP signals when passing an event structure back to TAPI.

  
Return Value:

    S_OK
    E_INVALIDARG
    E_OUTOFMEMORY
    TAPI_E_REGISTERCALLBACK

--*/
{
    LOG((MSP_TRACE, 
        "MSP address %x initialize entered, htEvent:%x",
        this, htEvent));

    if ( htEvent == NULL )
    {
        LOG((MSP_ERROR, " bad handle: htEvent:%x", htEvent));

        return E_INVALIDARG;
    }

    // lock the event related data
    m_EventDataLock.Lock();

    if (m_htEvent != NULL)
    {
        m_EventDataLock.Unlock();

        LOG((MSP_ERROR, "Initialze called twice."));
        return E_UNEXPECTED;
    }

    // save handles.
    m_htEvent   = htEvent;
    
    InitializeListHead(&m_EventList);

    HRESULT hr;

    // release the lock on the event related data
    m_EventDataLock.Unlock();

    // lock the terminal related data. This is a auto lock that will unlock
    // when the function returns.
    CLock lock(m_TerminalDataLock);

    // Create the terminal manager.
    hr = CoCreateInstance(
        CLSID_TerminalManager,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITTerminalManager,
        (void **) &m_pITTerminalManager
        );

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, 
            "Creating terminal manager failed. return: %x", hr));

        return hr;
    }

    hr = g_Thread.Start();    

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, 
            "Creating thread failed. return: %x", hr));

        return hr;
    }

    hr = g_Thread.RegisterPnpNotification(this);
    
    if (FAILED(hr))
    {
        LOG((MSP_ERROR,
            "Unable to register for PNP notification. return: %x", hr));
    }

    LOG((MSP_TRACE, 
        "MSP address %x initialize exited S_OK, htEvent:%x",
        this, htEvent));

    return S_OK;   
}

STDMETHODIMP CMSPAddress::Shutdown ()
/*++

Routine Description:

This method is called by TAPI3 when this address in not in use any more. 
This function releases the terminals and releases the terminal manager.
It releases all unprocessed events, and also stops the worker thread.
When this functions is called, no call should be alive. However, bugs in
the app may keep calls or terminals  around. Currently this function
does not attempt to solve this problem. The calls will have their own
refcounts on the terminals, so it shouldn't fail anyway.

Arguments:
    None.

Return Value:

    S_OK
--*/
{
    LOG((MSP_TRACE, "CMSPAddress::Shutdown - "
        "MSP address %x is shutting down", this));

    HRESULT hr;

    //
    // Unregister for PNP notification
    //

    hr = g_Thread.UnregisterPnpNotification(this);

    if (FAILED(hr))
    {
        LOG((MSP_ERROR,
            "Unable to unregister for PNP notification. return: %x", hr));
    }

    //
    // Tell the worker thread to stop.
    //

    g_Thread.Stop();    

    LOG((MSP_INFO, "CMSPAddress::Shutdown - thread has stopped"));

    // acquire the lock on the terminal data because we are writing to it.
    m_TerminalDataLock.Lock();

    // Release the terminal manager.
    if (m_pITTerminalManager != NULL)
    {
        m_pITTerminalManager->Release();
        m_pITTerminalManager = NULL;
    }

    // release all the terminals.
    for (int i = 0; i < m_Terminals.GetSize(); i ++)
    {
        //
        // Clear its CMSPAddress pointer
        //
        CBaseTerminal * pCTerminal = static_cast<CBaseTerminal *> (m_Terminals[i]);

        m_Terminals[i]->Release();
    }
    m_Terminals.RemoveAll();

    // We are done with terminal related data, release the lock.
    m_TerminalDataLock.Unlock();


    LOG((MSP_INFO, "CMSPAddress::Shutdown - terminals released"));

    // acquire the lock on the event data because we are writing to it.
    m_EventDataLock.Lock();
    
    m_htEvent = NULL;

    // release all the unprocessed events in the list.
    while (!IsListEmpty(&m_EventList)) 
    {
        // retrieve first entry
        PLIST_ENTRY pLE = RemoveHeadList(&m_EventList);

        // convert list entry to structure pointer
        PMSPEVENTITEM pItem = CONTAINING_RECORD(pLE, MSPEVENTITEM, Link);

        // release the refcount in the event.
        LOG((MSP_INFO, 
            "CMSPAddress::Shutdown:releasing event still in the queue: %x",
            pItem->MSPEventInfo.Event
            ));

        switch (pItem->MSPEventInfo.Event)
        {
        case ME_ADDRESS_EVENT:
            if (pItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.pTerminal)
            {
                pItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.pTerminal->Release();
            }
            break;

        case ME_CALL_EVENT:
            if (pItem->MSPEventInfo.MSP_CALL_EVENT_INFO.pStream)
            {
                pItem->MSPEventInfo.MSP_CALL_EVENT_INFO.pStream->Release();
            }

            if (pItem->MSPEventInfo.MSP_CALL_EVENT_INFO.pTerminal)
            {
                pItem->MSPEventInfo.MSP_CALL_EVENT_INFO.pTerminal->Release();
            }
            break;

        case ME_PRIVATE_EVENT:
            if (pItem->MSPEventInfo.MSP_PRIVATE_EVENT_INFO.pEvent)
            {
                pItem->MSPEventInfo.MSP_PRIVATE_EVENT_INFO.pEvent->Release();
            }
            break;

        case ME_TSP_DATA:
            // nothing inside the structure that we need to free
            break;

        case ME_FILE_TERMINAL_EVENT:

            if( NULL != pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pParentFileTerminal)
            {
                (pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pParentFileTerminal)->Release();
                pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pParentFileTerminal = NULL;
            }

            if( NULL != pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pFileTrack )
            {
                (pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pFileTrack)->Release();
                pItem->MSPEventInfo.MSP_FILE_TERMINAL_EVENT_INFO.pFileTrack = NULL;
            }

            break;

        case ME_ASR_TERMINAL_EVENT:

            if( NULL != pItem->MSPEventInfo.MSP_ASR_TERMINAL_EVENT_INFO.pASRTerminal)
            {
                (pItem->MSPEventInfo.MSP_ASR_TERMINAL_EVENT_INFO.pASRTerminal)->Release();
            }

            break;

        case ME_TTS_TERMINAL_EVENT:

            if( NULL != pItem->MSPEventInfo.MSP_TTS_TERMINAL_EVENT_INFO.pTTSTerminal)
            {
                (pItem->MSPEventInfo.MSP_TTS_TERMINAL_EVENT_INFO.pTTSTerminal)->Release();
            }

            break;

        case ME_TONE_TERMINAL_EVENT:

            if( NULL != pItem->MSPEventInfo.MSP_TONE_TERMINAL_EVENT_INFO.pToneTerminal)
            {
                (pItem->MSPEventInfo.MSP_TONE_TERMINAL_EVENT_INFO.pToneTerminal)->Release();
            }

            break;

        default:
            LOG((MSP_WARN, "CMSPAddress::Shutdown: unknown event type: %x",
                pItem->MSPEventInfo.Event));            

            break;
        }

        FreeEventItem(pItem);
    }

    // We are done with event related data, release the lcok.
    m_EventDataLock.Unlock();

    LOG((MSP_TRACE, "CMSPAddress::Shutdown - exit S_OK"));

    return S_OK;
}


STDMETHODIMP CMSPAddress::ReceiveTSPData(
    IN      IUnknown        *   pMSPCall,
    IN      LPBYTE              pBuffer,
    IN      DWORD               dwBufferSize
    )
/*++

Routine Description:

This method is called by TAPI3 when the TSP address sends data to this 
MSP address object. The semantics of the data passed in the buffer are
specific to each  TSP - MSP pair. This method dispatches the received
buffer to the address (call == NULL) or call (call != NULL).

Arguments:

pMSPCall
    The call object that the data is for. If it is NULL, the data is for 
    this address.

pBuffer
    Opaque buffer from TSP.

dwBufferSize
    Size in bytes of pBuffer


    
Return Value:

    S_OK

--*/
{
    LOG((MSP_TRACE, "CMSPAddress::ReceiveTSPData entered. pMSPCall:%x",
        pMSPCall));

    _ASSERTE(dwBufferSize > 0);
    _ASSERTE(!IsBadReadPtr(pBuffer, sizeof(BYTE) * (dwBufferSize) ) );

    HRESULT hr;
    
    if ( NULL == pMSPCall )
    {
        hr = ReceiveTSPAddressData(pBuffer, dwBufferSize);

        if ( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::ReceiveTSPData - "
                "ReceiveTSPAddressData failed - exit 0x%08x", hr));

            return hr;
        }

        LOG((MSP_TRACE, "CMSPAddress::ReceiveTSPData - "
            "exit S_OK (dispatched to address)"));

        return S_OK;
    }

    //
    // We have a call to dispatch to.
    //

    _ASSERTE(!IsBadReadPtr(pMSPCall, sizeof(IUnknown) ) );
    
    ITStreamControl * pIStreamControl;

    hr = pMSPCall->QueryInterface(IID_ITStreamControl,
                                  (void **)&pIStreamControl);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::ReceiveTSPData - "
            "can't get the ITStream Control interface - exit 0x%08x", hr));

        return hr;
    }

    CMSPCallBase * pCall = static_cast<CMSPCallBase *> (pIStreamControl);

    if (pCall == NULL)
    {
        LOG((MSP_ERROR, "CMSPAddress::ReceiveTSPData - "
            "invalid msp call pointer: %x", pMSPCall));

        pIStreamControl->Release();

        return E_UNEXPECTED;
    }
    
    hr = pCall->ReceiveTSPCallData(pBuffer, dwBufferSize);

    pIStreamControl->Release();

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::ReceiveTSPData - "
            "method on call failed - exit 0x%08x", hr));

        return hr;
    }

    LOG((MSP_TRACE, "CMSPAddress::ReceiveTSPData - "
        "exit S_OK (dispatched to call)"));

    return S_OK;
}


HRESULT CMSPAddress::GetStaticTerminals(
    IN OUT  DWORD *             pdwNumTerminals,
    OUT     ITTerminal **       ppTerminals
    )
/*++

Routine Description:

This method is called by TAPI3 to get a list of static terminals that can 
be used on this address. If our list is not empty, just return the list. 
If our list is still empty, create the static terminals and return the list.
Derived class can override this method to have their own terminals. Locks 
the terminal lists.

Arguments:

pdwNumTerminals
    Pointer to a DWORD.  On entry, indicates the size of the buffer pointed 
    to in ppTerminals. On success, it will be filled in with the actual number
    of terminals returned.  If the buffer is not big enough, the method will 
    return TAPI_E_NOTENOUGHMEMORY, and it will be filled in the with number
    of terminals needed. 

ppTerminals
    On success, filled in with an array of terminals object pointers that are 
    supported by the MSP for this address.  This value may be NULL, in which 
    case pdwNumTerminals will return the needed buffer size.

    
Return Value:

S_OK
E_OUTOFMEMORY
TAPI_E_NOTENOUGHMEMORY

--*/
{
    LOG((MSP_TRACE, 
        "GetStaticTerminals entered. NumTerminals:%x, ppTerminals:%x",
        *pdwNumTerminals, ppTerminals
        ));

    // lock the terminal related data. This is a auto lock that will unlock
    // when the function returns.
    CLock lock(m_TerminalDataLock);

    if (!m_fTerminalsUpToDate)
    {
        HRESULT hr = UpdateTerminalList();

        if (FAILED(hr))
        {
            LOG((MSP_ERROR,
                "CMSPAddress::GetStaticTerminals - "
                "UpdateTerminalList failed - returning 0x%08x", hr));

            return hr;
        }
    }

    //
    // Check if initialized.
    //

    if ( m_htEvent == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::GetStaticTerminals - "
            "not initialized - returning E_UNEXPECTED"));

        return E_UNEXPECTED;
    }

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(pdwNumTerminals, sizeof(DWORD) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::GetStaticTerminals - "
            "bad pdwNumTerminals pointer - exit E_POINTER"));

        return E_POINTER;
    }
    
    if ( ppTerminals != NULL )
    {
        if ( MSPB_IsBadWritePtr(ppTerminals,
                           *pdwNumTerminals * sizeof(ITTerminal *) ) )
        {
            LOG((MSP_ERROR, "CMSPAddress::GetStaticTerminals - "
                "bad ppTerminals pointer - exit E_POINTER"));

            return E_POINTER;
        }
    }


    //
    // Grab the size of the terminals list.
    //

    int   iSize = m_Terminals.GetSize();
    _ASSERTE( iSize >= 0 );

    //
    // Add our terminals to the output list if the caller wants an output
    // list, and provided there is enough room in the output list.
    //

    if ( ( ppTerminals != NULL ) &&
         ( (DWORD) iSize <= *pdwNumTerminals ) )
    {
        //
        // For each terminal in the list of terminals we created,
        // AddRef and copy the terminal pointer.
        //

        for (int i = 0; i < iSize; i++)
        {
            m_Terminals[i]->AddRef();

            ppTerminals[i] = m_Terminals[i];
        }
    }
    
    //
    // If there was no output list then we just have to report the number
    // of terminals available.
    //
    
    if ( ppTerminals == NULL )
    {
        *pdwNumTerminals = (DWORD) iSize;

        LOG((MSP_TRACE,
            "CMSPAddress::GetStaticTerminals - just returned number of "
            "terminals available - exit S_OK"));

        return S_OK;
    }
    
    //
    // If there was an output list but it was not large enough, then
    // return the appropriate error.
    //
    
    if ( (DWORD) iSize > *pdwNumTerminals )
    {
        *pdwNumTerminals = (DWORD) iSize;

        LOG((MSP_ERROR,
            "CMSPAddress::GetStaticTerminals - passed-in array not "
            "large enough - exit TAPI_E_NOTENOUGHMEMORY"));

        return TAPI_E_NOTENOUGHMEMORY;
    }
    
    //
    // Otherwise, everything was fine. We just need to report the actual
    // number of terminals we copied and return S_OK.
    //
    
    *pdwNumTerminals = (DWORD) iSize;
    
    LOG((MSP_TRACE,
        "CMSPAddress::GetStaticTerminals - "
        "returned terminals - exit S_OK"));

    return S_OK;
}

HRESULT CMSPAddress::IsMonikerInTerminalList(IMoniker* pMoniker)
{
    CSingleFilterStaticTerminal *pCSingleFilterStaticTerminal;

    //
    // Grab the size of the terminals list.
    //

    int   iSize = m_Terminals.GetSize();
    _ASSERTE( iSize >= 0 );

    //
    // Add our terminals to the output list if the caller wants an output
    // list, and provided there is enough room in the output list.
    //

    for (int i = 0; i < iSize; i++)
    {
        pCSingleFilterStaticTerminal = static_cast<CSingleFilterStaticTerminal *>(m_Terminals[i]);

        if ( pCSingleFilterStaticTerminal->CompareMoniker( pMoniker ) == S_OK )
        {
            LOG((MSP_TRACE, "CMSPAddress::IsMonikerInTerminalList - "
                "moniker found in terminal list"));

            pCSingleFilterStaticTerminal->m_bMark = TRUE;  // mark this terminal so we don't remove it

            return S_OK;
        }

    }

    LOG((MSP_TRACE, "CMSPAddress::IsMonikerInTerminalList - "
                "moniker not found in terminal list"));
    return S_FALSE;
}

HRESULT CMSPAddress::UpdateTerminalListForPnp(
        IN  BOOL    bDeviceArrival
        )
{
    CSingleFilterStaticTerminal *pCSingleFilterStaticTerminal;

    //
    // Clear all marks in the terminal list
    //

    int   iSize = m_Terminals.GetSize();
    _ASSERTE( iSize >= 0 );

    for (int i = 0; i < iSize; i++)
    {
        pCSingleFilterStaticTerminal = static_cast<CSingleFilterStaticTerminal *>(m_Terminals[i]);

        if (pCSingleFilterStaticTerminal == NULL)
        {           
            LOG((MSP_ERROR, "CMSPAddress::IsMonikerInTerminalList - "
                    "bad terminal pointer"));
            return E_FAIL;
        }

        pCSingleFilterStaticTerminal->m_bMark = FALSE;
    }

    //
    // Create DevEnum, which is the DirectShow Category Enumerator Creator
    //

    HRESULT hr;
    ICreateDevEnum * pCreateDevEnum;

    hr = CoCreateInstance(CLSID_SystemDeviceEnum,
                          NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_ICreateDevEnum,
                          (void**)&pCreateDevEnum);

    if (FAILED(hr)) 
    {
        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp "
               "can't CoCreate DevEnum - returning  0x%08x", hr));
        return hr;
    }    

    IEnumMoniker  * pCatEnum;

    for ( i = 0; i < m_sdwTerminalTypesCount; i++ )
    {
        //
        // Skip any terminal types that don't use one of the supported media
        // modes.
        //

        if ( ! IsValidSingleMediaType( 
            m_saTerminalTypes[i].dwMediaType, GetCallMediaTypes() ) )
        {
            continue;
        }


        //
        // Create the actual category enumerator.
        //

        hr = pCreateDevEnum->CreateClassEnumerator(
                                *(m_saTerminalTypes[i].clsidClassManager),
                                &pCatEnum,
                                0);

        if ( hr != S_OK ) // S_FALSE means the category does not exist!
        {
            LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp "
                   "can't create class enumerator - returning 0x%08x", hr));

            continue;
        }

        IMoniker      * pMoniker;

        while ((hr = pCatEnum->Next(1, &pMoniker, NULL)) == S_OK)
        {
            if (IsMonikerInTerminalList(pMoniker) == S_FALSE)
            {
                //
                // Create a terminal and give it its moniker.
                //

                ITTerminal * pTerminal;
                hr = (m_saTerminalTypes[i].pfnCreateTerm)(pMoniker,
                                                          (MSP_HANDLE) this,
                                                          &pTerminal);

                //
                // The terminal keeps a reference to the moniker if it needs to.
                //

                pMoniker->Release();

                if (SUCCEEDED(hr))
                {
                    //
                    // Add this terminal pointer to our list. Don't release it; we
                    // keep this one reference to it in the list.
                    //

                    BOOL fSuccess = m_Terminals.Add(pTerminal);

                    if ( ! fSuccess )
                    {
                        pCatEnum->Release();
                        pTerminal->Release();

                        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                            "can't add terminal to list; returning E_OUTOFMEMORY"));

                        return E_OUTOFMEMORY;
                    }

                    //
                    // Set its CMSPAddress pointer
                    //
                    CBaseTerminal * pCTerminal = static_cast<CBaseTerminal *> (pTerminal);

                    //
                    // Mark this terminal so we don't remove it
                    //

                    pCSingleFilterStaticTerminal = static_cast<CSingleFilterStaticTerminal *>(pTerminal);

                    if (pCSingleFilterStaticTerminal == NULL)
                    {           
                        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                                "bad terminal pointer"));
                        return E_FAIL;
                    }

                    pCSingleFilterStaticTerminal->m_bMark = TRUE;

                    //
                    // Post a TAPI message about the new terminal's arrival
                    //

                    pTerminal->AddRef();

                    MSPEVENTITEM *pEventItem;

                    pEventItem = AllocateEventItem();

                    if (pEventItem == NULL)
                    {
                        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                        "can't allocate event item; returning E_OUTOFMEMORY"));

                        pTerminal->Release();
                        return E_OUTOFMEMORY;
                    }

                    pEventItem->MSPEventInfo.dwSize = sizeof(MSP_EVENT_INFO);
                    pEventItem->MSPEventInfo.Event = ME_ADDRESS_EVENT;
                    pEventItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.Type = ADDRESS_TERMINAL_AVAILABLE;
                    pEventItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.pTerminal = pTerminal;

                    hr = PostEvent(pEventItem);

                    if (FAILED(hr))
                    {
                        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                        "post event failed"));

                        pTerminal->Release();
                        FreeEventItem(pEventItem);
                    } 
                    
                }
            }

            //
            // If it failed, that either means we skipped the device because it
            // was unsuitable (a routine occurance) or something failed, like
            // out of memory. I should come up with a way to differentiate and
            // handle this well.
            //
        }

        //
        // We are done with the enumerator.
        //

        pCatEnum->Release();
    }

    //
    // Release DevEnum.
    //

    pCreateDevEnum->Release();

    //
    // Sweep the terminal list and clean up any terminals which are no longer present
    //

    iSize = m_Terminals.GetSize();
    _ASSERTE( iSize >= 0 );

    for (i = 0; i < iSize; i++)
    {
        pCSingleFilterStaticTerminal = static_cast<CSingleFilterStaticTerminal *>(m_Terminals[i]);

        if (pCSingleFilterStaticTerminal == NULL)
        {           
            LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                    "bad terminal pointer"));
            return E_FAIL;
        }

        if (!pCSingleFilterStaticTerminal->m_bMark)
        {        
            //
            // This terminal has is no longer present, lets remove it from the list
            //

            LOG((MSP_TRACE, "CMSPAddress::UpdateTerminalListForPnp "
                   "found a terminal to be removed"));

            ITTerminal * pTerminal = m_Terminals[i];

            if (m_Terminals.RemoveAt(i))
            {
                //
                // Clear its CMSPAddress pointer
                //
                CBaseTerminal * pCTerminal = static_cast<CBaseTerminal *> (pTerminal);
                
                //
                // We don't release the terminal here even though we are removing
                // it from the terminal list because TAPI3.dll will release it
                // when it releases the event.
                //

                //
                // Post a TAPI message about the new terminal's removal
                //

                MSPEVENTITEM *pEventItem;

                pEventItem = AllocateEventItem();

                if (pEventItem == NULL)
                {
                    LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                    "can't allocate event item; returning E_OUTOFMEMORY"));

                    pTerminal->Release();
                    return E_OUTOFMEMORY;
                }

                pEventItem->MSPEventInfo.dwSize = sizeof(MSP_EVENT_INFO);
                pEventItem->MSPEventInfo.Event = ME_ADDRESS_EVENT;
                pEventItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.Type = ADDRESS_TERMINAL_UNAVAILABLE;
                pEventItem->MSPEventInfo.MSP_ADDRESS_EVENT_INFO.pTerminal = pTerminal;

                hr = PostEvent(pEventItem);

                if (FAILED(hr))
                {
                    LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalListForPnp - "
                    "post event failed"));

                    pTerminal->Release();
                    FreeEventItem(pEventItem);
                }
            
                //
                // fix up our search indices to account for a removal
                //
            
                iSize--;
                i--;
            }
        }
    }

    //
    // Our list is now complete.
    //

    m_fTerminalsUpToDate = TRUE;
    
    LOG((MSP_TRACE, "CMSPAddress::UpdateTerminalListForPnp - exit S_OK"));

    return S_OK;
}


HRESULT CMSPAddress::UpdateTerminalList(void)
{
    //
    // Create DevEnum, which is the DirectShow Category Enumerator Creator
    //

    HRESULT hr;
    ICreateDevEnum * pCreateDevEnum;

    hr = CoCreateInstance(CLSID_SystemDeviceEnum,
                          NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_ICreateDevEnum,
                          (void**)&pCreateDevEnum);

    if (FAILED(hr)) 
    {
        LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalList "
               "can't CoCreate DevEnum - returning  0x%08x", hr));
        return hr;
    }    

    IEnumMoniker  * pCatEnum;

    for ( DWORD i = 0; i < m_sdwTerminalTypesCount; i++ )
    {
        //
        // Skip any terminal types that don't use one of the supported media
        // modes.
        //

        if ( ! IsValidSingleMediaType( 
            m_saTerminalTypes[i].dwMediaType, GetCallMediaTypes() ) )
        {
            continue;
        }


        //
        // Create the actual category enumerator.
        //

        hr = pCreateDevEnum->CreateClassEnumerator(
                                *(m_saTerminalTypes[i].clsidClassManager),
                                &pCatEnum,
                                0);

        if ( hr != S_OK ) // S_FALSE means the category does not exist!
        {
            LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalList "
                   "can't create class enumerator - returning 0x%08x", hr));

            continue;
        }

        IMoniker      * pMoniker;

        while ((hr = pCatEnum->Next(1, &pMoniker, NULL)) == S_OK)
        {
            //
            // Create a terminal and give it its moniker.
            //

            ITTerminal * pTerminal;
            hr = (m_saTerminalTypes[i].pfnCreateTerm)(pMoniker,
                                                      (MSP_HANDLE) this,
                                                      &pTerminal);

            //
            // The terminal keeps a reference to the moniker if it needs to.
            //

            pMoniker->Release();

            if (SUCCEEDED(hr))
            {
                //
                // Add this terminal pointer to our list. Don't release it; we
                // keep this one reference to it in the list.
                //

                BOOL fSuccess = m_Terminals.Add(pTerminal);

                if ( ! fSuccess )
                {
                    pCatEnum->Release();

                    LOG((MSP_ERROR, "CMSPAddress::UpdateTerminalList - "
                        "can't add terminal to list; returning E_OUTOFMEMORY"));

                    return E_OUTOFMEMORY;
                }
                //
                // Set its CMSPAddress pointer
                //
                CBaseTerminal * pCTerminal = static_cast<CBaseTerminal *> (pTerminal);

            }

            //
            // If it failed, that either means we skipped the device because it
            // was unsuitable (a routine occurance) or something failed, like
            // out of memory. I should come up with a way to differentiate and
            // handle this well.
            //
        }

        //
        // We are done with the enumerator.
        //

        pCatEnum->Release();
    }

    //
    // Release DevEnum.
    //

    pCreateDevEnum->Release();

    //
    // Our list is now complete.
    //

    m_fTerminalsUpToDate = TRUE;
    
    LOG((MSP_TRACE, "CMSPAddress::UpdateTerminalList - exit S_OK"));

    return S_OK;
}

HRESULT CMSPAddress::GetDynamicTerminalClasses(
    IN OUT  DWORD *             pdwNumClasses,
    OUT     IID *               pTerminalClasses
    )
/*++

Routine Description:

This method is called by TAPI3 to get a list of dynamic terminal guids 
that can be used on this address. It asks the terminal manager for the 
list of guids and returns them. Derived class can override this method 
to have their own guids.


Arguments:

pdwNumClasses
    Pointer to a DWORD.  On entry, indicates the size of the buffer 
    pointed to in pTerminalClasses. On success, it will be filled in 
    with the actual number of class IIDs returned.  If the buffer is 
    not big enough, the method will return TAPI_E_NOTENOUGHMEMORY, 
    and it will be filled in the with number of IIDs needed. 

pTerminalClasses

    On success, filled in with an array of terminal class IIDs that 
    are supported by the MSP for this address.  This value may be NULL, 
    in which case pdwNumClasses will return the needed buffer size.
    
Return Value:

S_OK
E_OUTOFMEMORY
TAPI_E_NOTENOUGHMEMORY

--*/
{
    LOG((MSP_TRACE,
        "CMSPAddress::GetDynamicTerminalClasses - enter"));

    //
    // Check if initialized.
    //

    // lock the event related data
    m_EventDataLock.Lock();

    if ( m_htEvent == NULL )
    {
        // unlock the event related data
        m_EventDataLock.Unlock();

        LOG((MSP_ERROR,
            "CMSPAddress::GetDynamicTerminalClasses - "
            "not initialized - returning E_UNEXPECTED"));

        return E_UNEXPECTED;
    }

    // unlock the event related data
    m_EventDataLock.Unlock();

    //
    // Ask the Terminal Manager for the dynamic terminals that apply to
    // all of our supported media types. Since the mapping is
    // direct, the Terminal Manager takes care of all argument checking.
    //

    HRESULT hr;

    hr = m_pITTerminalManager->GetDynamicTerminalClasses(
                                                  GetCallMediaTypes(),
                                                  pdwNumClasses,
                                                  pTerminalClasses);


    LOG((MSP_TRACE,
        "CMSPAddress::GetDynamicTerminalClasses - exit 0x%08x", hr));

    return hr;
}

STDMETHODIMP CMSPAddress::CreateTerminal(
    IN      BSTR                pTerminalClass,
    IN      long                lMediaType,
    IN      TERMINAL_DIRECTION  Direction,
    OUT     ITTerminal **       ppTerminal
    )
/*++

Routine Description:

This method is called by TAPI3 to create a dynamic terminal. It asks the 
terminal manager to create a dynamic terminal. Derived class can
override this method to have their own way of creating a dynamic terminal.

Arguments:

iidTerminalClass
    IID of the terminal class to be created.

dwMediaType
    TAPI media type of the terminal to be created.

Direction
    Terminal direction of the terminal to be created.

ppTerminal
    Returned created terminal object
    
Return Value:

S_OK

E_OUTOFMEMORY
TAPI_E_INVALIDMEDIATYPE
TAPI_E_INVALIDTERMINALDIRECTION
TAPI_E_INVALIDTERMINALCLASS

--*/
{
    LOG((MSP_TRACE,
        "CMSPAddress::CreateTerminal - enter"));

    //
    // Check if initialized.
    //

    // lock the event related data
    m_EventDataLock.Lock();

    if ( m_htEvent == NULL )
    {
        // unlock the event related data
        m_EventDataLock.Unlock();

        LOG((MSP_ERROR,
            "CMSPAddress::CreateTerminal - "
            "not initialized - returning E_UNEXPECTED"));

        return E_UNEXPECTED;
    }

    // unlock the event related data
    m_EventDataLock.Unlock();

    //
    // Get the IID from the BSTR representation.
    //

    HRESULT hr;
    IID     iidTerminalClass;

    hr = CLSIDFromString(pTerminalClass, &iidTerminalClass);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::CreateTerminal - "
            "bad CLSID string - returning E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // Make sure we support the requested media type.
    // The terminal manager checks the terminal class, terminal direction, 
    // and return pointer.
    //


    
    //
    // requested media type may be aggregated, but it must still be valid
    //

    if ( !IsValidAggregatedMediaType(lMediaType) )
    {
        LOG((MSP_ERROR, "CMSPAddress::CreateTerminal - "
            "unrecognized media type requested - returning E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // Use the terminal manager to create the dynamic terminal.
    //

    _ASSERTE( m_pITTerminalManager != NULL );

    hr = m_pITTerminalManager->CreateDynamicTerminal(NULL,
                                                     iidTerminalClass,
                                                     (DWORD) lMediaType,
                                                     Direction,
                                                     (MSP_HANDLE) this,
                                                     ppTerminal);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::CreateTerminal - "
            "create dynamic terminal failed - returning 0x%08x", hr));

        return hr;
    }

    LOG((MSP_TRACE, "CMSPAddress::CreateTerminal - exit S_OK"));

    return S_OK;
}

STDMETHODIMP CMSPAddress::GetDefaultStaticTerminal(
    IN      long                lMediaType,
    IN      TERMINAL_DIRECTION  Direction,
    OUT     ITTerminal **       ppTerminal
    )
/*++

Routine Description:

This method is called by TAPI3 to get the default static terminal 
for a certain type and direction. It updates the list if needed, then
figures out which terminal is the first of the appropriate type in our
list. Derived classes can override this method to have 
their own way of deciding which terminal is the default. Locks the 
terminal lists.


Arguments:

dwMediaType
    The TAPIMEDIATYPE of the terminal to retrieve.  Only one bit will be set.

Direction
    TERMINAL_DIRECTION of the terminal to retrieve.

ppTerminal
    Default terminal returned

    
Return Value:

S_OK

E_POINTER
E_OUTOFMEMORY
TAPI_E_NOTSUPPORTED
TAPI_E_INVALIDMEDIATYPE
TAPI_E_INVALIDTERMINALDIRECTION

--*/
{
    LOG((MSP_TRACE,
        "CMSPAddress::GetDefaultStaticTerminal - enter"));

    //
    // Check if initialized.
    //

    // lock the event related data
    m_EventDataLock.Lock();

    if ( m_htEvent == NULL )
    {
        // unlock the event related data
        m_EventDataLock.Unlock();

        LOG((MSP_ERROR,
            "CMSPAddress::GetDefaultStaticTerminal - "
            "not initialized - returning E_UNEXPECTED"));

        return E_UNEXPECTED;
    }
    // unlock the event related data
    m_EventDataLock.Unlock();

    //
    // Make sure we support this media type.
    //

    if ( ! IsValidSingleMediaType( (DWORD) lMediaType, GetCallMediaTypes() ) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::GetDefaultStaticTerminal - "
            "non-audio terminal requested - returning E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // Check the direction.
    //

    if ( ( Direction != TD_CAPTURE ) && ( Direction != TD_RENDER ) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::GetDefaultStaticTerminal - "
            "invalid direction - returning E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // Check return pointer.
    //

    if ( MSPB_IsBadWritePtr(ppTerminal, sizeof(ITTerminal *) ) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::GetDefaultStaticTerminal - "
            "bad terminal return pointer - returning E_POINTER"));

        return E_POINTER;
    }

    // lock the terminal related data. This is a auto lock that will unlock
    // when the function returns.
    CLock lock(m_TerminalDataLock);

    if (!m_fTerminalsUpToDate)
    {
       HRESULT hr = UpdateTerminalList();

        if (FAILED(hr))
        {
            LOG((MSP_ERROR,
                "CMSPAddress::GetDefaultStaticTerminal - "
                "UpdateTerminalList failed - returning 0x%08x", hr));

            return hr;
        }
    }

    //
    // For each terminal in the list of terminals we created...
    //

    int iSize = m_Terminals.GetSize();

    for (int i = 0; i < iSize; i++)
    {
        ITTerminal * pTerminal = m_Terminals[i];

        HRESULT      hr;

        //
        // Make sure this is the right direction.
        // 

        TERMINAL_DIRECTION dir;

        hr = pTerminal->get_Direction(&dir);

        if (FAILED(hr))
        {
            LOG((MSP_WARN,
                "CMSPAddress::GetDefaultStaticTerminal - "
                "could not get terminal direction - skipping"));

            continue;
        }

        if ( dir != Direction )
        {
            continue;
        }

        //
        // Make sure this is the right media type.
        //

        long lMediaTypeObserved;

        hr = pTerminal->get_MediaType(&lMediaTypeObserved);

        if (FAILED(hr))
        {
            LOG((MSP_WARN,
                "CMSPAddress::GetDefaultStaticTerminal - "
                "could not get terminal media type - skipping"));

            continue;
        }

        if ( ( lMediaTypeObserved & lMediaType) == 0 )
        {
            continue;
        }

        //
        // Ok, so this is the terminal we want. Addref it and give it to the
        // caller.
        //

        pTerminal->AddRef();

        *ppTerminal = pTerminal;

        LOG((MSP_TRACE,
            "CMSPAddress::GetDefaultStaticTerminal - "
            "returned a terminal - exit S_OK"));

        return S_OK;
    }
    
    //
    // If we get here then we did not find any matching terminals.
    //

    LOG((MSP_TRACE,
        "CMSPAddress::GetDefaultStaticTerminal - "
        "no match - exit TAPI_E_NOITEMS"));

    return TAPI_E_NOITEMS;
}

STDMETHODIMP CMSPAddress::get_PluggableSuperclasses( 
    OUT VARIANT * pVariant
    )
{
    LOG((MSP_TRACE,
        "CMSPAddress::get_PluggableSuperclasses - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(pVariant, sizeof(VARIANT) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // Get ITTemrinalManager2
    //

    ITTerminalManager2* pTermMgr2 = NULL;
    HRESULT hr = E_FAIL;
    hr = m_pITTerminalManager->QueryInterface(
        IID_ITTerminalManager2, (void**)&pTermMgr2);

    if( FAILED(hr) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::get_PluggableSuperclasses - "
            "QI for ITTerminalManager2 failed - returning 0x%08x", hr));
        return hr;
    }

    //
    // Create the collection object - see mspcoll.h
    //

    typedef CTapiIfCollection< ITPluggableTerminalSuperclassInfo* > SuperclassCollection;
    CComObject<SuperclassCollection> * pCollection;
    hr = CComObject<SuperclassCollection>::CreateInstance( &pCollection );

    if ( FAILED(hr) )
    {
        //Clean-up
        pTermMgr2->Release();

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "can't create collection - exit 0x%08x", hr));

        return hr;
    }

    //
    // Get the Collection's IDispatch interface
    //

    IDispatch * pDispatch;
    hr = pCollection->_InternalQueryInterface(
        IID_IDispatch,
        (void **) &pDispatch );

    if ( FAILED(hr) )
    {
        //Clean-up
        pTermMgr2->Release();
        delete pCollection;

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "QI for IDispatch on collection failed - exit 0x%08x", hr));
        return hr;
    }

    //
    // Find out how many superclasses are available.
    //

    DWORD   dwNumSuperclasses = 0;

    hr = pTermMgr2->GetPluggableSuperclasses(
            &dwNumSuperclasses,
            NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "can't get number of terminals - exit 0x%08x", hr));

        //Clean-up
        pTermMgr2->Release();
        pDispatch->Release();

        return hr;
    }

    //
    // Allocate an array of IID.
    //

    IID* pSuperclassesIID = new IID[dwNumSuperclasses];
    if ( pSuperclassesIID == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "can't allocate IIDs array - exit E_OUTOFMEMORY"));

        //Clean-up
        pTermMgr2->Release();
        pDispatch->Release();

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = pTermMgr2->GetPluggableSuperclasses(
            &dwNumSuperclasses,
            pSuperclassesIID
            );

    //
    // Clean-up
    //

    pTermMgr2->Release();

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "can't get IIDs - exit 0x%08x", hr));

        //Clean-up
        pDispatch->Release();
        delete[] pSuperclassesIID;

        return hr;
    }

    //
    // Allocate an array of ITPluggableTerminalSuperclassInfo
    //
    typedef ITPluggableTerminalSuperclassInfo* SuperclassPtr; // MS parser
    SuperclassPtr * ppSuperclassesInfo = new SuperclassPtr[dwNumSuperclasses];
    if ( ppSuperclassesInfo == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "can't allocate SuperclassPtr array - exit E_OUTOFMEMORY"));

        //Clean-up
        pDispatch->Release();
        delete[] pSuperclassesIID;

        return E_OUTOFMEMORY;
    }

    //
    // Get ITPluggableTerminalSuperclassRegistration interface
    //

    ITPluggableTerminalSuperclassRegistration* pSuperclassReg = NULL;
    hr = CoCreateInstance(
        CLSID_PluggableSuperclassRegistration,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITPluggableTerminalSuperclassRegistration,
        (void**)&pSuperclassReg
        );
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
            "QI for ITPluggableTerminalSuperclassRegistration - exit 0x%08x",hr));

        //Clean-up
        pDispatch->Release();
        delete[] pSuperclassesIID;
        delete[] ppSuperclassesInfo;

        return hr;
    }

    //
    // Create the objects
    //

    for(DWORD dwIndex = 0; dwIndex < dwNumSuperclasses; dwIndex++)
    {
        //
        // Get the string from the IID
        //
        LPOLESTR lpszCLSID = NULL;
        hr = StringFromIID( pSuperclassesIID[dwIndex], &lpszCLSID);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
                "StringFromIID failed - exit 0x%08x",hr));

            //Clean-up
            pDispatch->Release();
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();

            return hr;
        }

        //
        // Get BSTR for IID
        //
        BSTR bstrCLSID = SysAllocString( lpszCLSID );
        CoTaskMemFree( lpszCLSID ); // Clean-up
        if( NULL == bstrCLSID)
        {
            LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
                "SysAllocString failed - exit E_OUTOFMEMORY"));

            // Clean-up
            pDispatch->Release();
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();

            return E_OUTOFMEMORY;
        }

        //
        // Read information from registry
        //

        pSuperclassReg->put_CLSID( bstrCLSID);
        hr = pSuperclassReg->GetTerminalSuperclassInfo();
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
                "GetTerminalSuperclassInfo failed - exit 0x%08x",hr));

            // Clean-up
            pDispatch->Release();
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();
            SysFreeString( bstrCLSID);

            return hr;
        }

        //
        // Get the name
        //
        BSTR bstrName = NULL;
        pSuperclassReg->get_Name( &bstrName );

        //
        // Create the information object
        //
        CComObject<CPlugTerminalSuperclassInfo>* pSuperclassInfo = NULL;
        hr = CComObject<CPlugTerminalSuperclassInfo>::CreateInstance(&pSuperclassInfo);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - "
                "CreateInstance failed - exit 0x%08x", hr));

            //Clean-up
            pDispatch->Release();
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();
            SysFreeString( bstrCLSID );
            SysFreeString( bstrName );

            return hr;
        }

        //
        // Get ITPluggableTerminalSuperclassInfo from this superclass
        //

        pSuperclassInfo->QueryInterface(
            IID_ITPluggableTerminalSuperclassInfo, 
            (void**)&ppSuperclassesInfo[dwIndex]
            );

        //
        // Set the fields
        //

        pSuperclassInfo->put_Name( bstrName);
        pSuperclassInfo->put_CLSID( bstrCLSID );

        //
        // Clean-up
        //
        SysFreeString( bstrCLSID );
        SysFreeString( bstrName );
    }


    //
    // Clean-up the IIDs array
    //

    pSuperclassReg->Release();
    delete[] pSuperclassesIID;

    //
    // Init the collection using an iterator -- pointers to the beginning and
    // the ending element plus one. If it succeeds, this method addrefs each
    // element of ppterminals by querying for IDispatch.
    //

    hr = pCollection->Initialize( dwNumSuperclasses,
                                  ppSuperclassesInfo,
                                  ppSuperclassesInfo + dwNumSuperclasses );

    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableSuperclasses - exit "
            "pCollection->Initialize failed. returns 0x%08x", hr));

        delete[] ppSuperclassesInfo;
        pDispatch->Release();

        return hr;
    }

    //
    // put the IDispatch interface pointer into the variant
    //

    LOG((MSP_INFO, "CMSPAddress::get_PluggableSuperclasses - "
        "placing IDispatch value %08x in variant", pDispatch));

    VariantInit(pVariant);
    pVariant->vt = VT_DISPATCH;
    pVariant->pdispVal = pDispatch;

    LOG((MSP_TRACE, "CMSPAddress::get_PluggableSuperclasses - exit S_OK"));

    return S_OK;
}

STDMETHODIMP CMSPAddress::EnumeratePluggableSuperclasses( 
    OUT IEnumPluggableSuperclassInfo** ppSuperclassEnumerator 
    )
{
    LOG((MSP_TRACE,
        "CMSPAddress::EnumeratePluggableSuperclasses - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(ppSuperclassEnumerator, sizeof(IEnumPluggableTerminalClassInfo*) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // Get ITTemrinalManager2
    //

    ITTerminalManager2* pTermMgr2 = NULL;
    HRESULT hr = E_FAIL;
    hr = m_pITTerminalManager->QueryInterface(
        IID_ITTerminalManager2, (void**)&pTermMgr2);

    if( FAILED(hr) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::EnumeratePluggableSuperclasses - "
            "QI for ITTerminalManager2 failed - returning 0x%08x", hr));
        return hr;
    }

    //
    // Find out how many superclasses are available.
    //

    DWORD   dwNumSuperclasses = 0;

    hr = pTermMgr2->GetPluggableSuperclasses(
            &dwNumSuperclasses,
            NULL);

    if ( FAILED(hr) )
    {
        // Clean-up
        pTermMgr2->Release();

        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't get number of terminals - exit 0x%08x", hr));

        return hr;
    }

    //
    // Allocate an array of IID.
    //

    IID* pSuperclassesIID = new IID[dwNumSuperclasses];
    if ( pSuperclassesIID == NULL )
    {
        // Clean-up
        pTermMgr2->Release();

        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't allocate IIDs array - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = pTermMgr2->GetPluggableSuperclasses(
            &dwNumSuperclasses,
            pSuperclassesIID
            );

    //
    // Clean-up
    //

    pTermMgr2->Release();

    if ( FAILED(hr) )
    {
        //Clean-up
        delete[] pSuperclassesIID;

        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't get IIDs - exit 0x%08x", hr));

        return hr;
    }

    //
    // Allocate an array of ITPluggableTerminalSuperclassInfo
    //
    typedef ITPluggableTerminalSuperclassInfo* SuperclassPtr; // MS parser
    SuperclassPtr * ppSuperclassesInfo = new SuperclassPtr[dwNumSuperclasses];
    if ( ppSuperclassesInfo == NULL )
    {
        // Clean-up
        delete[] pSuperclassesIID;

        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't allocate SuperclassPtr array - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Get ITPluggableTerminalSuperclassRegistration interface
    //

    ITPluggableTerminalSuperclassRegistration* pSuperclassReg = NULL;
    hr = CoCreateInstance(
        CLSID_PluggableSuperclassRegistration,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITPluggableTerminalSuperclassRegistration,
        (void**)&pSuperclassReg
        );
    if( FAILED(hr) )
    {
        // Clean-up
        delete[] pSuperclassesIID;
        delete[] ppSuperclassesInfo;

        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "QI for ITPluggableTerminalSuperclassRegistration - exit 0x%08x",hr));

        return hr;
    }

    //
    // Create the objects
    //

    for(DWORD dwIndex = 0; dwIndex < dwNumSuperclasses; dwIndex++)
    {
        //
        // Get the string from the IID
        //
        LPOLESTR lpszCLSID = NULL;
        hr = StringFromIID( pSuperclassesIID[dwIndex], &lpszCLSID);
        if( FAILED(hr) )
        {
            //Clean-up
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();

            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
                "StringFromIID failed - exit 0x%08x",hr));

            return hr;
        }

        //
        // Get BSTR for IID
        //
        BSTR bstrCLSID = SysAllocString( lpszCLSID );
        CoTaskMemFree( lpszCLSID ); // Clean-up
        if( NULL == bstrCLSID)
        {
            //Clean-up
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();

            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
                "SysAllocString failed - exit E_OUTOFMEMORY"));

            return E_OUTOFMEMORY;
        }

        //
        // Read information from registry
        //

        pSuperclassReg->put_CLSID( bstrCLSID);
        hr = pSuperclassReg->GetTerminalSuperclassInfo();
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
                "GetTerminalSuperclassInfo failed - exit 0x%08x",hr));

            // Clean-up
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();
            SysFreeString( bstrCLSID);

            return hr;
        }

        //
        // Get the name
        //
        BSTR bstrName = NULL;
        pSuperclassReg->get_Name( &bstrName );

        //
        // Create the information object
        //
        CComObject<CPlugTerminalSuperclassInfo>* pSuperclassInfo = NULL;
        hr = CComObject<CPlugTerminalSuperclassInfo>::CreateInstance(&pSuperclassInfo);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
                "CreateInstance failed - exit 0x%08x", hr));

            // Clean-up
            delete[] pSuperclassesIID;
            delete[] ppSuperclassesInfo;
            pSuperclassReg->Release();
            SysFreeString( bstrCLSID );
            SysFreeString( bstrName );

            return hr;
        }

        //
        // Get ITPluggableTerminalSuperclassInfo from this superclass
        //

        pSuperclassInfo->QueryInterface(
            IID_ITPluggableTerminalSuperclassInfo, 
            (void**)&ppSuperclassesInfo[dwIndex]
            );

        //
        // Set the fields
        //

        pSuperclassInfo->put_Name( bstrName);
        pSuperclassInfo->put_CLSID( bstrCLSID );

        //
        // Clean-up
        //
        SysFreeString( bstrCLSID );
        SysFreeString( bstrName );
    }


    //
    // Clean-up the IIDs array
    //

    pSuperclassReg->Release();
    delete[] pSuperclassesIID;

    //
    // Create the enumerator object.
    //

    typedef CSafeComEnum<IEnumPluggableSuperclassInfo,
                     &IID_IEnumPluggableSuperclassInfo,
                     ITPluggableTerminalSuperclassInfo*, 
                     _CopyInterface<ITPluggableTerminalSuperclassInfo> > CEnumerator;

    CComObject<CEnumerator> *pEnum = NULL;

    hr = CComObject<CEnumerator>::CreateInstance(&pEnum);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't create enumerator - exit 0x%08x", hr));

        delete[] ppSuperclassesInfo;
        return hr;
    }

    //
    // Query for the desired interface.
    //

    hr = pEnum->_InternalQueryInterface(
        IID_IEnumPluggableSuperclassInfo, 
        (void**) ppSuperclassEnumerator
        );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't get enumerator interface - exit 0x%08x", hr));

        delete pEnum;
        delete[] ppSuperclassesInfo;
        
        return hr;
    }

    //
    // Init the enumerator object.
    //

    hr = pEnum->Init(ppSuperclassesInfo,
                     ppSuperclassesInfo + dwNumSuperclasses,
                     NULL,
                     AtlFlagTakeOwnership); 

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableSuperclasses - "
            "can't init enumerator - exit 0x%08x", hr));

        (*ppSuperclassEnumerator)->Release();
        delete[] ppSuperclassesInfo;
        
        return hr;
    }
    
    LOG((MSP_TRACE, "CMSPAddress::EnumeratePluggableSuperclasses - exit S_OK"));

    return S_OK;
}

STDMETHODIMP CMSPAddress::get_PluggableTerminalClasses( 
    IN  BSTR bstrTerminalSuperclass,
    IN  long lMediaType,
    OUT VARIANT * pVariant
    )
{
    LOG((MSP_TRACE,
        "CMSPAddress::get_PluggableTerminalClasses - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(pVariant, sizeof(VARIANT) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    if( IsBadStringPtr( bstrTerminalSuperclass, (UINT)-1))
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "bad pointer argument - exit E_INVALIDARG"));

        return E_INVALIDARG;
    }

    IID iidSuperclass = IID_NULL;
    HRESULT hr = IIDFromString( bstrTerminalSuperclass, &iidSuperclass);
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "bad pointer argument - exit E_INVALIDARG"));

        return E_INVALIDARG;
    }

    //
    // Get ITTemrinalManager2
    //

    ITTerminalManager2* pTermMgr2 = NULL;
    hr = m_pITTerminalManager->QueryInterface(
        IID_ITTerminalManager2, (void**)&pTermMgr2);

    if( FAILED(hr) )
    {
        LOG((MSP_ERROR,
            "CMSPAddress::get_PluggableTerminalClasses - "
            "QI for ITTerminalManager2 failed - returning 0x%08x", hr));
        return hr;
    }

    //
    // Create the collection object - see mspcoll.h
    //

    typedef CTapiIfCollection< ITPluggableTerminalClassInfo* > ClassCollection;
    CComObject<ClassCollection> * pCollection;
    hr = CComObject<ClassCollection>::CreateInstance( &pCollection );

    if ( FAILED(hr) )
    {
        //Clean-up
        pTermMgr2->Release();

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "can't create collection - exit 0x%08x", hr));

        return hr;
    }

    //
    // Get the Collection's IDispatch interface
    //

    IDispatch * pDispatch;
    hr = pCollection->_InternalQueryInterface(
        IID_IDispatch,
        (void **) &pDispatch );

    if ( FAILED(hr) )
    {
        // Clean-up
        pTermMgr2->Release();
        delete pCollection;

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "QI for IDispatch on collection failed - exit 0x%08x", hr));

        return hr;
    }

    //
    // Find out how many superclasses are available.
    //

    DWORD   dwNumClasses = 0;

    hr = pTermMgr2->GetPluggableTerminalClasses(
            iidSuperclass,
            lMediaType,
            &dwNumClasses,
            NULL);

    if ( FAILED(hr) )
    {
        //Clean-up
        pTermMgr2->Release();
        pDispatch->Release();

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "can't get number of terminals - exit 0x%08x", hr));

        return hr;
    }

    //
    // Allocate an array of IID.
    //

    IID* pClassesIID = new IID[dwNumClasses];
    if ( pClassesIID == NULL )
    {
        //Clean-up
        pTermMgr2->Release();
        pDispatch->Release();

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "can't allocate IIDs array - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = pTermMgr2->GetPluggableTerminalClasses(
            iidSuperclass,
            lMediaType,
            &dwNumClasses,
            pClassesIID
            );

    //
    // Clean-up
    //

    pTermMgr2->Release();

    if ( FAILED(hr) )
    {
        //Clean-up
        pDispatch->Release();
        delete[] pClassesIID;

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "can't get IIDs - exit 0x%08x", hr));

        return hr;
    }

    //
    // Allocate an array of ITPluggableTerminalClassInfo
    //
    typedef ITPluggableTerminalClassInfo* ClassPtr;
    ClassPtr * ppClassesInfo = new ClassPtr[dwNumClasses];
    if ( ppClassesInfo == NULL )
    {
        //Clean-up
        pDispatch->Release();
        delete[] pClassesIID;

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "can't allocate ClassPtr array - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Get ITPluggableTerminalClassRegistration interface
    //

    ITPluggableTerminalClassRegistration* pClassReg = NULL;
    hr = CoCreateInstance(
        CLSID_PluggableTerminalRegistration,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITPluggableTerminalClassRegistration,
        (void**)&pClassReg
        );
    if( FAILED(hr) )
    {
        //Clean-up
        pDispatch->Release();
        delete[] pClassesIID;
        delete[] ppClassesInfo;

        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
            "QI for ITPluggableTerminalClassRegistration - exit 0x%08x",hr));

        return hr;
    }

    //
    // Create the objects
    //

    for(DWORD dwIndex = 0; dwIndex < dwNumClasses; dwIndex++)
    {
        //
        // Get the string from the IID
        //
        LPOLESTR lpszPublicCLSID = NULL;
        hr = StringFromIID( pClassesIID[dwIndex], &lpszPublicCLSID);
        if( FAILED(hr) )
        {
            //Clean-up
            pDispatch->Release();
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();

            LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
                "StringFromIID failed - exit 0x%08x",hr));

            return hr;
        }

        //
        // Get BSTR for IID
        //
        BSTR bstrPublicCLSID = SysAllocString( lpszPublicCLSID );
        CoTaskMemFree( lpszPublicCLSID ); // Clean-up
        if( NULL == bstrPublicCLSID)
        {
            //Clean-up
            pDispatch->Release();
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();

            LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
                "SysAllocString failed - exit E_OUTOFMEMORY"));

            return E_OUTOFMEMORY;
        }

        //
        // Read information from registry
        //

        pClassReg->put_TerminalClass( bstrPublicCLSID);
        hr = pClassReg->GetTerminalClassInfo(
            bstrTerminalSuperclass);
        if( FAILED(hr) )
        {
            // Clean-up
            pDispatch->Release();
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();
            SysFreeString( bstrPublicCLSID);

            LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
                "GetTerminalInfo failed - exit 0x%08x",hr));

            return hr;
        }

        //
        // Get the name
        //
        BSTR bstrName = NULL;
        pClassReg->get_Name( &bstrName );
        BSTR bstrCompany = NULL;
        pClassReg->get_Company( &bstrCompany );
        BSTR bstrVersion = NULL;
        pClassReg->get_Version( &bstrVersion );
        BSTR bstrCLSID = NULL;
        pClassReg->get_CLSID( &bstrCLSID );
        TMGR_DIRECTION Direction = TMGR_TD_CAPTURE;
        pClassReg->get_Direction( &Direction );
        long lMediaType = 0;
        pClassReg->get_MediaTypes( &lMediaType );

        //
        // Create the information object
        //
        CComObject<CPlugTerminalClassInfo>* pClassInfo = NULL;
        hr = CComObject<CPlugTerminalClassInfo>::CreateInstance(&pClassInfo);
        if( FAILED(hr) )
        {
            //Clean-up
            pDispatch->Release();
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();
            SysFreeString( bstrPublicCLSID );
            SysFreeString( bstrName );
            SysFreeString( bstrCompany );
            SysFreeString( bstrVersion );
            SysFreeString( bstrCLSID );

            LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - "
                "CreateInstance failed - exit 0x%08x", hr));

            return hr;
        }

        //
        // Get ITPluggableTerminalClassInfo from this superclass
        //

        pClassInfo->QueryInterface(
            IID_ITPluggableTerminalClassInfo, 
            (void**)&ppClassesInfo[dwIndex]
            );

        //
        // Set the fields
        //

        if( NULL == bstrName)
        {
            bstrName = SysAllocString(L"");
        }
        pClassInfo->put_Name( bstrName);
        pClassInfo->put_TerminalClass( bstrPublicCLSID );
        if( NULL == bstrCompany)
        {
            bstrCompany = SysAllocString(L"");
        }
        pClassInfo->put_Company( bstrCompany );
        if( NULL == bstrVersion)
        {
            bstrVersion = SysAllocString(L"");
        }
        pClassInfo->put_Version( bstrVersion );
        if( NULL == bstrCLSID)
        {
            LPOLESTR lpszCLSID = NULL;
            StringFromCLSID( CLSID_NULL, &lpszCLSID);
            bstrCLSID = SysAllocString(lpszCLSID);
            CoTaskMemFree( lpszCLSID);
        }
        pClassInfo->put_CLSID( bstrCLSID );
        TERMINAL_DIRECTION TermDirection = TD_CAPTURE;
        switch( Direction )
        {
        case TMGR_TD_RENDER:
            TermDirection = TD_RENDER;
            break;
        case TMGR_TD_BOTH:
            TermDirection = TD_BIDIRECTIONAL;
            break;
        case TMGR_TD_CAPTURE:
        default:
            TermDirection = TD_CAPTURE;
            break;
        }
        pClassInfo->put_Direction( TermDirection );
        pClassInfo->put_MediaTypes( lMediaType );

        //
        // Clean-up
        //
        SysFreeString( bstrPublicCLSID );
        SysFreeString( bstrName );
        SysFreeString( bstrCompany );
        SysFreeString( bstrVersion );
        SysFreeString( bstrCLSID );
    }


    //
    // Clean-up the IIDs array
    //

    pClassReg->Release();
    delete[] pClassesIID;

    //
    // Init the collection using an iterator -- pointers to the beginning and
    // the ending element plus one. If it succeeds, this method addrefs each
    // element of ppterminals by querying for IDispatch.
    //

    hr = pCollection->Initialize( dwNumClasses,
                                  ppClassesInfo,
                                  ppClassesInfo + dwNumClasses );

    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_PluggableTerminalClasses - exit "
            "pCollection->Initialize failed. returns 0x%08x", hr));

        delete[] ppClassesInfo;
        pDispatch->Release();

        return hr;
    }

    //
    // put the IDispatch interface pointer into the variant
    //

    LOG((MSP_INFO, "CMSPAddress::get_PluggableTerminalClasses - "
        "placing IDispatch value %08x in variant", pDispatch));

    VariantInit(pVariant);
    pVariant->vt = VT_DISPATCH;
    pVariant->pdispVal = pDispatch;

    LOG((MSP_TRACE, "CMSPAddress::get_PluggableTerminalClasses - exit S_OK"));

    return S_OK;
}

STDMETHODIMP CMSPAddress::EnumeratePluggableTerminalClasses(
    IN  CLSID iidTerminalSuperclass,
    IN  long lMediaType,
    OUT IEnumPluggableTerminalClassInfo ** ppClassEnumerator 
    )
{
    LOG((MSP_TRACE,
        "CMSPAddress::EnumeratePluggableTerminalClasses - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(ppClassEnumerator, sizeof(IEnumPluggableTerminalClassInfo *) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    LPOLESTR lpszCLSID = NULL;
    HRESULT hr = StringFromCLSID( iidTerminalSuperclass, &lpszCLSID);
    if( FAILED(hr) )
    {
         LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "StringFromCLSID failed - exit 0x%08x", hr));

        return hr;
    }

    BSTR bstrTerminalSuperclass = SysAllocString( lpszCLSID );

    // Clean-up
    CoTaskMemFree(lpszCLSID);
    lpszCLSID = NULL;


    if( NULL == bstrTerminalSuperclass )
    {
         LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "SysAllocString failed - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Get ITTemrinalManager2
    //

    ITTerminalManager2* pTermMgr2 = NULL;
    hr = m_pITTerminalManager->QueryInterface(
        IID_ITTerminalManager2, (void**)&pTermMgr2);

    if( FAILED(hr) )
    {
        //Clean-up
        SysFreeString( bstrTerminalSuperclass );

        LOG((MSP_ERROR,
            "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "QI for ITTerminalManager2 failed - returning 0x%08x", hr));
        return hr;
    }

    //
    // Find out how many superclasses are available.
    //

    DWORD   dwNumClasses = 0;

    hr = pTermMgr2->GetPluggableTerminalClasses(
            iidTerminalSuperclass,
            lMediaType,
            &dwNumClasses,
            NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't get number of terminals - exit 0x%08x", hr));

        // Clean-up
        SysFreeString( bstrTerminalSuperclass );
        pTermMgr2->Release();

        return hr;
    }

    //
    // Allocate an array of IID.
    //

    IID* pClassesIID = new IID[dwNumClasses];
    if ( pClassesIID == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't allocate IIDs array - exit E_OUTOFMEMORY"));

        // Clean-up
        SysFreeString( bstrTerminalSuperclass );
        pTermMgr2->Release();

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = pTermMgr2->GetPluggableTerminalClasses(
            iidTerminalSuperclass,
            lMediaType,
            &dwNumClasses,
            pClassesIID
            );

    //
    // Clean-up
    //

    pTermMgr2->Release();

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't get IIDs - exit 0x%08x", hr));

        // Clean-up
        SysFreeString( bstrTerminalSuperclass );
        delete[] pClassesIID;

        return hr;
    }

    //
    // Allocate an array of ITPluggableTerminalClassInfo
    //
    typedef ITPluggableTerminalClassInfo* ClassPtr;
    ClassPtr * ppClassesInfo = new ClassPtr[dwNumClasses];
    if ( ppClassesInfo == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't allocate ClassPtr array - exit E_OUTOFMEMORY"));

        // Clean-up
        SysFreeString( bstrTerminalSuperclass );
        delete[] pClassesIID;

        return E_OUTOFMEMORY;
    }

    //
    // Get ITPluggableTerminalClassRegistration interface
    //

    ITPluggableTerminalClassRegistration* pClassReg = NULL;
    hr = CoCreateInstance(
        CLSID_PluggableTerminalRegistration,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITPluggableTerminalClassRegistration,
        (void**)&pClassReg
        );
    if( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "QI for ITPluggableTerminalClassRegistration - exit 0x%08x",hr));

        // Clean-up
        SysFreeString( bstrTerminalSuperclass );
        delete[] ppClassesInfo;
        delete[] pClassesIID;

        return hr;
    }

    //
    // Create the objects
    //

    for(DWORD dwIndex = 0; dwIndex < dwNumClasses; dwIndex++)
    {
        //
        // Get the string from the IID
        //
        LPOLESTR lpszPublicCLSID = NULL;
        hr = StringFromIID( pClassesIID[dwIndex], &lpszPublicCLSID);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
                "StringFromIID failed - exit 0x%08x",hr));

            // Clean-up
            SysFreeString( bstrTerminalSuperclass );
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();

            return hr;
        }

        //
        // Get BSTR for IID
        //
        BSTR bstrPublicCLSID = SysAllocString( lpszPublicCLSID );
        CoTaskMemFree( lpszPublicCLSID ); // Clean-up
        if( NULL == bstrPublicCLSID)
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
                "SysAllocString failed - exit E_OUTOFMEMORY"));


            // Clean-up
            SysFreeString( bstrTerminalSuperclass );
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();

            return E_OUTOFMEMORY;
        }

        //
        // Read information from registry
        //

        pClassReg->put_TerminalClass( bstrPublicCLSID);
        hr = pClassReg->GetTerminalClassInfo(
            bstrTerminalSuperclass);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
                "GetTerminalInfo failed - exit 0x%08x",hr));

            // Clean-up
            SysFreeString( bstrTerminalSuperclass );
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();
            SysFreeString( bstrPublicCLSID);

            return hr;
        }

        //
        // Get the name
        //
        BSTR bstrName = NULL;
        pClassReg->get_Name( &bstrName );
        BSTR bstrCompany = NULL;
        pClassReg->get_Company( &bstrCompany );
        BSTR bstrVersion = NULL;
        pClassReg->get_Version( &bstrVersion );
        BSTR bstrCLSID = NULL;
        pClassReg->get_CLSID( &bstrCLSID );
        TMGR_DIRECTION Direction = TMGR_TD_CAPTURE;
        pClassReg->get_Direction( &Direction );
        long lMediaType = 0;
        pClassReg->get_MediaTypes( &lMediaType );

        //
        // Create the information object
        //
        CComObject<CPlugTerminalClassInfo>* pClassInfo = NULL;
        hr = CComObject<CPlugTerminalClassInfo>::CreateInstance(&pClassInfo);
        if( FAILED(hr) )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
                "CreateInstance failed - exit 0x%08x", hr));

            // Clean-up
            SysFreeString( bstrTerminalSuperclass );
            delete[] pClassesIID;
            delete[] ppClassesInfo;
            pClassReg->Release();
            SysFreeString( bstrPublicCLSID );
            SysFreeString( bstrName );
            SysFreeString( bstrCompany );
            SysFreeString( bstrVersion );
            SysFreeString( bstrCLSID );

            return hr;
        }

        //
        // Get ITPluggableTerminalClassInfo from this superclass
        //

        pClassInfo->QueryInterface(
            IID_ITPluggableTerminalClassInfo, 
            (void**)&ppClassesInfo[dwIndex]
            );

        //
        // Set the fields
        //

        if( NULL == bstrName)
        {
            bstrName = SysAllocString(L"");
        }
        pClassInfo->put_Name( bstrName);
        pClassInfo->put_TerminalClass( bstrPublicCLSID );
        if( NULL == bstrCompany)
        {
            bstrCompany = SysAllocString(L"");
        }
        pClassInfo->put_Company( bstrCompany );
        if( NULL == bstrVersion)
        {
            bstrVersion = SysAllocString(L"");
        }
        pClassInfo->put_Version( bstrVersion );
        if( NULL == bstrCLSID)
        {
            LPOLESTR lpszCLSID = NULL;
            StringFromCLSID( CLSID_NULL, &lpszCLSID);
            bstrCLSID = SysAllocString(lpszCLSID);
            CoTaskMemFree( lpszCLSID);
        }
        pClassInfo->put_CLSID( bstrCLSID );
        TERMINAL_DIRECTION TermDirection = TD_CAPTURE;
        switch( Direction )
        {
        case TMGR_TD_RENDER:
            TermDirection = TD_RENDER;
            break;
        case TMGR_TD_BOTH:
            TermDirection = TD_BIDIRECTIONAL;
            break;
        case TMGR_TD_CAPTURE:
        default:
            TermDirection = TD_CAPTURE;
            break;
        }
        pClassInfo->put_Direction( TermDirection );
        pClassInfo->put_MediaTypes( lMediaType );

        //
        // Clean-up
        //
        SysFreeString( bstrPublicCLSID );
        SysFreeString( bstrName );
        SysFreeString( bstrCompany );
        SysFreeString( bstrVersion );
        SysFreeString( bstrCLSID );
    }


    //
    // Clean-up the IIDs array
    //

    SysFreeString( bstrTerminalSuperclass );
    delete[] pClassesIID;
    pClassReg->Release();

    //
    // Create the enumerator object.
    //

    typedef CSafeComEnum<IEnumPluggableTerminalClassInfo,
                     &IID_IEnumPluggableTerminalClassInfo,
                     ITPluggableTerminalClassInfo*, 
                     _CopyInterface<ITPluggableTerminalClassInfo> > CEnumerator;

    CComObject<CEnumerator> *pEnum = NULL;

    hr = CComObject<CEnumerator>::CreateInstance(&pEnum);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't create enumerator - exit 0x%08x", hr));

        delete[] ppClassesInfo;
        return hr;
    }

    //
    // Query for the desired interface.
    //

    hr = pEnum->_InternalQueryInterface(
        IID_IEnumPluggableTerminalClassInfo, 
        (void**) ppClassEnumerator
        );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't get enumerator interface - exit 0x%08x", hr));

        delete pEnum;
        delete[] ppClassesInfo;
        
        return hr;
    }

    //
    // Init the enumerator object.
    //

    hr = pEnum->Init(ppClassesInfo,
                     ppClassesInfo + dwNumClasses,
                     NULL,
                     AtlFlagTakeOwnership); 

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumeratePluggableTerminalClasses - "
            "can't init enumerator - exit 0x%08x", hr));

        (*ppClassEnumerator)->Release();
        delete[] ppClassesInfo;
        
        return hr;
    }
    
    LOG((MSP_TRACE, "CMSPAddress::EnumeratePluggableTerminalClasses - exit S_OK"));

    return S_OK;
}

STDMETHODIMP CMSPAddress::GetEvent(
    IN OUT  DWORD *             pdwSize,
    OUT     BYTE *              pBuffer
    )
/*++

Routine Description:

This method is called by TAPI3 to get detailed information about the 
event that just happened. TAPI3 will normally do this after its event 
is signaled. Locks the event list.

Arguments:

pMSPEvent
    The MSP_EVENT

pdwSize
    Pointer to a DWORD.  On entry, indicates the size in bytes of the 
    buffer pointed to in pbuffer. On success, it will be filled in with 
    the actual number of bytes returned.  If the buffer is not big enough, 
    the method will return TAPI_E_NOTENOUGHMEMORY, and it will be filled 
    in the with number of bytes needed. 

pBuffer
    Event buffer filled in by MSP with the relevant events
    
Return Value:

S_OK
E_OUTOFMEMORY
TAPI_E_NOEVENT
TAPI_E_NOTENOUGHMEMORY

--*/
{
    // We trust TAPI3 not to give us bad pointers.
    _ASSERTE(!MSPB_IsBadWritePtr(pdwSize, sizeof (DWORD *)));
    _ASSERTE((*pdwSize == 0) ? TRUE : 
        !MSPB_IsBadWritePtr(pBuffer, sizeof(BYTE) * (*pdwSize)));

    LOG((MSP_TRACE, "CMSPAddress::GetEvent"));

    CLock lock(m_EventDataLock);

    if (IsListEmpty(&m_EventList))
    {
        return TAPI_E_NOEVENT;
    }

    // retrieve first entry
    PLIST_ENTRY pLE = m_EventList.Flink;

    // convert list entry to structure pointer
    PMSPEVENTITEM pItem = CONTAINING_RECORD(pLE, MSPEVENTITEM, Link);

    if (pItem->MSPEventInfo.dwSize > *pdwSize)
    {
        *pdwSize = pItem->MSPEventInfo.dwSize;
        return TAPI_E_NOTENOUGHMEMORY;
    }
    
    CopyMemory(pBuffer, &pItem->MSPEventInfo, pItem->MSPEventInfo.dwSize);
    *pdwSize = pItem->MSPEventInfo.dwSize;

    // remove the first entry from the event list.
    RemoveHeadList(&m_EventList);

    // free the memory.
    FreeEventItem(pItem);

    return S_OK;
}

HRESULT CMSPAddress::PostEvent(
        IN      MSPEVENTITEM *      pEventItem
        )
/*++

Routine Description:

This method is called by MSPCalls to post an event to TAPI3. This method 
puts the event at the end of the event list and singals TAPI3. 
Locks the event list.


Arguments:

EventItem
    The event to be queued.
    
Return Value:

S_OK
E_OUTOFMEMORY

--*/
{
    CLock lock(m_EventDataLock);

    if (m_htEvent == NULL)
    {
        return E_UNEXPECTED;  // the address was shut down.
    }

    InsertTailList(&m_EventList, &pEventItem->Link);

    SetEvent(m_htEvent);

    return S_OK;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// OLE Automation wrappers


STDMETHODIMP CMSPAddress::get_StaticTerminals (
        OUT  VARIANT * pVariant
        )
{
    LOG((MSP_TRACE, "CMSPAddress::get_StaticTerminals - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(pVariant, sizeof(VARIANT) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // create the collection object - see mspcoll.h
    //

    typedef CTapiIfCollection< ITTerminal * > TerminalCollection;
    CComObject<TerminalCollection> * pCollection;
    HRESULT hr = CComObject<TerminalCollection>::CreateInstance( &pCollection );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "can't create collection - exit 0x%08x", hr));

        return hr;
    }

    //
    // get the Collection's IDispatch interface
    //

    IDispatch * pDispatch;

    hr = pCollection->_InternalQueryInterface(IID_IDispatch,
                                              (void **) &pDispatch );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "QI for IDispatch on collection failed - exit 0x%08x", hr));

        delete pCollection;

        return hr;
    }

    //
    // Find out how many terminals are available.
    //

    DWORD   dwNumTerminals;

    hr = GetStaticTerminals(&dwNumTerminals,
                            NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "can't get number of terminals - exit 0x%08x", hr));

        pDispatch->Release();

        return hr;
    }

    //
    // Allocate an array of terminal pointers.
    //

    typedef ITTerminal * TermPtr;
    TermPtr * ppTerminals = new TermPtr[dwNumTerminals];

    if ( ppTerminals == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "can't allocate terminals array - exit E_OUTOFMEMORY"));

        pDispatch->Release();

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = GetStaticTerminals(&dwNumTerminals,
                            ppTerminals);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "can't get terminals - exit 0x%08x", hr));

        pDispatch->Release();
        delete ppTerminals;

        return hr;
    }
    //
    // Init the collection using an iterator -- pointers to the beginning and
    // the ending element plus one. If it succeeds, this method addrefs each
    // element of ppterminals by querying for IDispatch.
    //

    hr = pCollection->Initialize( dwNumTerminals,
                                  ppTerminals,
                                  ppTerminals + dwNumTerminals );

    //
    // Release the ITTerminal reference to each terminal (leaving the
    // IDispatch reference, if any). Then delete the array; the
    // collection is now storing the pointers.
    //

    for (DWORD i = 0; i < dwNumTerminals; i++)
    {
        ppTerminals[i]->Release();
    }

    delete ppTerminals;
    
    if (FAILED(hr))
    {
        LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
            "Initialize on collection failed - exit 0x%08x", hr));
        
        pDispatch->Release();

        return hr;
    }

    //
    // put the IDispatch interface pointer into the variant
    //

    LOG((MSP_ERROR, "CMSPAddress::get_StaticTerminals - "
        "placing IDispatch value %08x in variant", pDispatch));

    VariantInit(pVariant);
    pVariant->vt = VT_DISPATCH;
    pVariant->pdispVal = pDispatch;

    LOG((MSP_TRACE, "CMSPAddress::get_StaticTerminals - exit S_OK"));
 
    return S_OK;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CMSPAddress::EnumerateStaticTerminals (
        OUT  IEnumTerminal ** ppTerminalEnumerator
        )
{
    LOG((MSP_TRACE, "CMSPAddress::EnumerateStaticTerminals - "
        "enter"));

    //
    // Check the return pointer.
    //

    if ( MSPB_IsBadWritePtr(ppTerminalEnumerator, sizeof(IEnumTerminal *) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "bad return pointer - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // Create the enumerator object.
    //

    typedef _CopyInterface<ITTerminal> CCopy;
    typedef CSafeComEnum<IEnumTerminal, &IID_IEnumTerminal,
        ITTerminal *, CCopy> CEnumerator;

    HRESULT hr;

    CComObject<CEnumerator> *pEnum = NULL;

    hr = CComObject<CEnumerator>::CreateInstance(&pEnum);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "can't create enumerator - exit 0x%08x", hr));

        return hr;
    }

    //
    // Query for the desired interface.
    //

    hr = pEnum->_InternalQueryInterface(IID_IEnumTerminal,
                                        (void**) ppTerminalEnumerator);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "can't get enumerator interface - exit 0x%08x", hr));

        delete pEnum;

        return hr;
    }

    //
    // Find out how many terminals are available.
    //

    DWORD   dwNumTerminals;

    hr = GetStaticTerminals(&dwNumTerminals,
                            NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "can't get number of terminals - exit 0x%08x", hr));

        (*ppTerminalEnumerator)->Release();

        return hr;
    }

    //
    // Allocate an array of terminal pointers.
    //

    typedef ITTerminal * TermPtr;
    TermPtr * ppTerminals = new TermPtr[dwNumTerminals];

    if ( ppTerminals == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "can't allocate terminals array - exit E_OUTOFMEMORY"));

        (*ppTerminalEnumerator)->Release();

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers. We must do this before
    // initializing the enumerator, because the enumerator may want to
    // addref the interface pointers during initialize.
    // 

    hr = GetStaticTerminals(&dwNumTerminals,
                            ppTerminals);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateStaticTerminals - "
            "can't get terminals - exit 0x%08x", hr));

        (*ppTerminalEnumerator)->Release();
        delete ppTerminals;

        return hr;
    }

    //
    // Initialize the object with the array of pointers.
    //

    hr = pEnum->Init(ppTerminals,
                     ppTerminals + dwNumTerminals,
                     NULL,
                     AtlFlagTakeOwnership);

    if (FAILED(hr))
    {
        LOG((MSP_ERROR, "CMSPCallBase::EnumerateStaticTerminals - "
            "init enumerator failed - exit 0x%08x", hr));

        for (DWORD i = 0; i < dwNumTerminals; i++)
        {
            ppTerminals[i]->Release();
        }
        
        delete ppTerminals;
        (*ppTerminalEnumerator)->Release();

        return hr;
    }

    LOG((MSP_TRACE, "CMSPAddress::EnumerateStaticTerminals - exit S_OK"));

    return S_OK;
}


//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CMSPAddress::get_DynamicTerminalClasses (
        OUT  VARIANT * pVariant
        )
{
    LOG((MSP_TRACE, "CMSPAddress::get_DynamicTerminalClasses - enter"));

    //
    // Check parameters.
    //

    if ( MSPB_IsBadWritePtr(pVariant, sizeof(VARIANT) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_DynamicTerminalClasses - "
            "bad pointer argument - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // create the collection object - see mspcoll.h
    //

    CComObject<CTapiBstrCollection> * pCollection;
    HRESULT hr = CComObject<CTapiBstrCollection>::CreateInstance( &pCollection );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_DynamicTerminalClasses - "
            "can't create collection - exit 0x%08x", hr));

        return hr;
    }

    //
    // get the Collection's IDispatch interface
    //

    IDispatch * pDispatch;

    hr = pCollection->_InternalQueryInterface(IID_IDispatch,
                                              (void **) &pDispatch );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_DynamicTerminalClasses - "
            "QI for IDispatch on collection failed - exit 0x%08x", hr));

        delete pCollection;

        return hr;
    }

    //
    // Find out how many terminals classes are available.
    //

    DWORD   dwNumClasses;

    hr = GetDynamicTerminalClasses(&dwNumClasses,
                                   NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't get number of terminal classes - exit 0x%08x", hr));

        pDispatch->Release();

        return hr;
    }

    //
    // Allocate an array of GUIDs.
    //

    IID * pClassGuids = new IID[dwNumClasses];

    if ( pClassGuids == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't allocate class guids array - exit E_OUTOFMEMORY"));

        pDispatch->Release();

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers.
    // 

    hr = GetDynamicTerminalClasses(&dwNumClasses,
                                   pClassGuids);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't get terminal class guids - exit 0x%08x", hr));

        pDispatch->Release();

        delete pClassGuids;

        return hr;
    }

    //
    // Allocate an array of BSTRs.
    //

    BSTR * pClassBstrs = new BSTR[dwNumClasses];

    if ( pClassBstrs == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't allocate class bstrs array - exit E_OUTOFMEMORY"));

        pDispatch->Release();

        delete pClassGuids;

        return E_OUTOFMEMORY;
    }

    //
    // Allocate a string for each GUID and copy it to the array,
    // then delete the array of GUIDs.
    //

    const int BUFSIZE = 100;
    WCHAR wszBuffer[BUFSIZE];

    for (DWORD i = 0; i < dwNumClasses; i++)
    {
        int ret = StringFromGUID2(pClassGuids[i], wszBuffer, BUFSIZE);

        _ASSERTE(ret != 0);

        pClassBstrs[i] = SysAllocString(wszBuffer);

        if ( pClassBstrs[i] == NULL )
        {
            LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
                "can't allocate a bstr - exit E_OUTOFMEMORY"));

            for (DWORD j = 0; j < i; j++)
            {
                SysFreeString(pClassBstrs[j]);
            }

            delete pClassBstrs;
            delete pClassGuids;

            pDispatch->Release();
    
            return E_OUTOFMEMORY;
        }
    }

    delete pClassGuids;

    //
    // Init the collection using an iterator -- pointers to the beginning and
    // the ending element plus one.
    //

    hr = pCollection->Initialize( dwNumClasses,
                                  pClassBstrs,
                                  pClassBstrs + dwNumClasses );

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::get_DynamicTerminalClasses - "
            "Initialize on collection failed - exit 0x%08x", hr));
        
        pDispatch->Release();

        for (DWORD k = 0; k < dwNumClasses; k++)
        {
            SysFreeString(pClassBstrs[k]);
        }
        
        delete pClassBstrs;

        return hr;
    }

    delete pClassBstrs;

    //
    // put the IDispatch interface pointer into the variant
    //

    LOG((MSP_ERROR, "CMSPAddress::get_DynamicTerminalClasses - "
        "placing IDispatch value %08x in variant", pDispatch));

    VariantInit(pVariant);
    pVariant->vt = VT_DISPATCH;
    pVariant->pdispVal = pDispatch;

    LOG((MSP_TRACE, "CMSPAddress::get_DynamicTerminalClasses - exit S_OK"));
 
    return S_OK;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CMSPAddress::EnumerateDynamicTerminalClasses (
        OUT  IEnumTerminalClass ** ppTerminalClassEnumerator
        )
{
    LOG((MSP_TRACE, "CMSPAddress::EnumerateDynamicTerminalClasses - enter"));

    //
    // Check the return pointer.
    //

    if ( MSPB_IsBadWritePtr(ppTerminalClassEnumerator,
                       sizeof(IEnumTerminalClass *) ) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "bad return pointer - exit E_POINTER"));

        return E_POINTER;
    }

    //
    // Find out how many terminals classes are available.
    //

    HRESULT hr;
    DWORD   dwNumClasses;

    hr = GetDynamicTerminalClasses(&dwNumClasses,
                                   NULL);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't get number of terminal classes - exit 0x%08x", hr));

        return hr;
    }

    //
    // Allocate an array of GUIDs.
    //

    IID * pClassGuids = new IID[dwNumClasses];

    if ( pClassGuids == NULL )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't allocate class guids array - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }

    //
    // Fill in the array with actual pointers.
    // 

    hr = GetDynamicTerminalClasses(&dwNumClasses,
                                   pClassGuids);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't get terminal class guids - exit 0x%08x", hr));

        delete pClassGuids;

        return hr;
    }


    //
    // Create an enumerator to hold this array, and have it take ownership
    // so that it will delete the array when it is released. The CSafeComEnum
    // can handle zero-length arrays. This Fn also checks the return arg.
    //

    //
    // Create the enumerator object.
    //

    typedef CSafeComEnum<IEnumTerminalClass,
                     &IID_IEnumTerminalClass,
                     GUID, _Copy<GUID> > CEnumerator;

    CComObject<CEnumerator> *pEnum = NULL;

    hr = CComObject<CEnumerator>::CreateInstance(&pEnum);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't create enumerator - exit 0x%08x", hr));

        delete pClassGuids;

        return hr;
    }

    //
    // Query for the desired interface.
    //

    hr = pEnum->_InternalQueryInterface(IID_IEnumTerminalClass, 
                                        (void**) ppTerminalClassEnumerator);

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't get enumerator interface - exit 0x%08x", hr));

        delete pEnum;
        delete pClassGuids;
        
        return hr;
    }

    //
    // Init the enumerator object.
    //

    hr = pEnum->Init(pClassGuids,
                     pClassGuids + dwNumClasses,
                     NULL,
                     AtlFlagTakeOwnership); 

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CMSPAddress::EnumerateDynamicTerminalClasses - "
            "can't init enumerator - exit 0x%08x", hr));

        (*ppTerminalClassEnumerator)->Release();
        delete pClassGuids;
        
        return hr;
    }

    LOG((MSP_TRACE, "CMSPAddress::EnumerateDynamicTerminalClasses - exit S_OK"));

    return S_OK;
}

HRESULT CMSPAddress::ReceiveTSPAddressData(
        IN      PBYTE               pBuffer,
        IN      DWORD               dwSize
        )
/*++

Routine Description:

  Base class receive TSP address data method... does nothing in base class.
  Implemented so that MSP's that only communicate per-call don't have
  to override it.

Arguments:

  
Return Value:

S_OK

--*/

{
    LOG((MSP_TRACE, "CMSPAddress::ReceiveTSPAddressData - enter"));
    LOG((MSP_TRACE, "CMSPAddress::ReceiveTSPAddressData - exit S_OK"));

    return S_OK;
}

HRESULT CMSPAddress::PnpNotifHandler(
        IN      BOOL                bDeviceArrival
        )
{
    LOG((MSP_TRACE, "CMSPAddress::PnpNotifHandler - enter"));

    if (bDeviceArrival)
        LOG((MSP_TRACE, "CMSPAddress::PnpNotifHandler - device arrival"));
    else
        LOG((MSP_TRACE, "CMSPAddress::PnpNotifHandler - device removal"));

    // lock the terminal related data. This is a auto lock that will unlock
    // when the function returns.
    CLock lock(m_TerminalDataLock);

    // if the terminal list hasn't been built yet, we can skip doing anything
    if (m_fTerminalsUpToDate)
    {
        HRESULT hr = UpdateTerminalListForPnp( bDeviceArrival );

        if (FAILED(hr))
        {
            LOG((MSP_ERROR,
                "CMSPAddress::PnpNotifHandler - "
                "UpdateTerminalList failed - returning 0x%08x", hr));

            return hr;
        }
    }

    LOG((MSP_TRACE, "CMSPAddress::PnpNotifHandler - exit S_OK"));

    return S_OK;
}

// eof