windows-server-2003/net/tapi/skywalker/h323/tsp/line.cpp

/*++

Copyright (c) 1999 Microsoft Corporation

Module Name:

    line.cpp

Abstract:

    TAPI Service Provider functions related to manipulating lines.

        TSPI_lineClose
        TSPI_lineGetDevCaps         
        TSPI_lineGetLineDevStatus
        TSPI_lineGetNumAddressIDs
        TSPI_lineOpen
        
Author:
    Nikhil Bobde (NikhilB)

Revision History:

--*/
 

//                                                                           
// Include files                                                             
//                                                                           


#include "globals.h"
#include "line.h"
#include "call.h"
#include "q931obj.h"
#include "ras.h"



static  LONG    g_CTCallIdentity;

CH323Line g_H323Line;

H323_OCTETSTRING g_ProductID =
{
    (BYTE*)H323_PRODUCT_ID,
    sizeof(H323_PRODUCT_ID)
};


H323_OCTETSTRING g_ProductVersion =
{
    (BYTE*)H323_PRODUCT_VERSION,
    sizeof(H323_PRODUCT_VERSION)
};


//Queues a request made by TAPI to the thread pool
BOOL
QueueTAPILineRequest(
    IN  DWORD       EventID,
    IN  HDRVCALL    hdCall1,
    IN  HDRVCALL    hdCall2,
    IN  DWORD       dwDisconnectMode,
    IN  WORD        wCallReference)
{
    BOOL fResult = TRUE;
    TAPI_LINEREQUEST_DATA * pLineRequestData = new TAPI_LINEREQUEST_DATA;
    
    H323DBG(( DEBUG_LEVEL_TRACE, "QueueTAPILineRequest entered." ));

    if( pLineRequestData != NULL )
    {
        pLineRequestData -> EventID = EventID;
        pLineRequestData -> hdCall1 = hdCall1;

        if( hdCall2 != NULL )
        {
            pLineRequestData -> hdCall2 = hdCall2;
        }
        else
        {
            pLineRequestData -> dwDisconnectMode = dwDisconnectMode;
        }
                
        pLineRequestData -> wCallReference = wCallReference;
        
        if( !QueueUserWorkItem( ProcessTAPILineRequest, pLineRequestData,
                WT_EXECUTEDEFAULT) )
        {
            delete pLineRequestData;
            fResult = FALSE;
        }
    }
    else
    {
        fResult = FALSE;
    }

    H323DBG(( DEBUG_LEVEL_TRACE, "QueueTAPILineRequest exited." ));
    return fResult;
}


#if    DBG

DWORD
ProcessTAPILineRequest(
	IN PVOID ContextParameter
    )
{
    __try
    {
        return ProcessTAPILineRequestFre( ContextParameter );
    }
    __except( 1 )
    {
        TAPI_LINEREQUEST_DATA*  pRequestData = (TAPI_LINEREQUEST_DATA*)ContextParameter;
        
        H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event threw exception: %p, %p, %d.",
            EventIDToString(pRequestData -> EventID),
            pRequestData -> hdCall1,
            pRequestData -> hdCall2,
            pRequestData -> wCallReference ));
        
        _ASSERTE( FALSE );

        return 0;
    }
}

#endif

DWORD
ProcessTAPILineRequestFre(
    IN  PVOID   ContextParam
    )
{
    _ASSERTE( ContextParam );

    PH323_CALL              pCall = NULL;
    PH323_CALL              pConsultCall = NULL;
    TAPI_LINEREQUEST_DATA*  pLineRequestData = (TAPI_LINEREQUEST_DATA*)ContextParam;

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event recvd.",
        EventIDToString(pLineRequestData -> EventID) ));

    switch( pLineRequestData -> EventID )
    {
    case TSPI_CLOSE_CALL:

        g_pH323Line -> H323ReleaseCall( 
            pLineRequestData->hdCall1, 
            pLineRequestData->dwDisconnectMode,
            pLineRequestData->wCallReference );
        break;

    case TSPI_COMPLETE_TRANSFER:

        pConsultCall = g_pH323Line -> Find2H323CallsAndLock( 
            pLineRequestData->hdCall2, pLineRequestData->hdCall1, &pCall );
        
        if( pConsultCall != NULL )
        {
            pConsultCall -> CompleteTransfer( pCall );

            pCall -> Unlock();
            pConsultCall -> Unlock();
        }
        break;
    }

    delete pLineRequestData;
    return EXIT_SUCCESS;
}



//                                                                           
// Private procedures                                                        
//                                                                           

CH323Line::CH323Line()
{
    m_nState = H323_LINESTATE_NONE;
    m_hdLine = NULL;
    m_htLine = NULL;
    m_dwDeviceID = -1;
    m_dwTSPIVersion = NULL;
    m_dwMediaModes = NULL;
    m_hdNextMSPHandle = NULL;
    m_wszAddr[0] = UNICODE_NULL;
    m_dwInitState = NULL;

    m_VendorInfo.bCountryCode = H221_COUNTRY_CODE_USA;
    m_VendorInfo.bExtension = H221_COUNTRY_EXT_USA;
    m_VendorInfo.wManufacturerCode = H221_MFG_CODE_MICROSOFT;
    m_VendorInfo.pProductNumber = &(g_ProductID);
    m_VendorInfo.pVersionNumber = &(g_ProductVersion); 

    m_pCallForwardParams = NULL;
    m_dwInvokeID = 256;
    m_fForwardConsultInProgress = FALSE;

}


PH323_CALL 
CH323Line::Find2H323CallsAndLock (
    IN  HDRVCALL hdCall1,
    IN  HDRVCALL hdCall2,
    OUT PH323_CALL * ppCall2
    )
{
    int iIndex1 = MakeCallIndex (hdCall1);
    int iIndex2 = MakeCallIndex (hdCall2);
    PH323_CALL  pCall1 = NULL, pCall2 = NULL;
    
    H323DBG(( DEBUG_LEVEL_TRACE, "Find2H323CallsAndLock entered:%lx:%lx.",
        hdCall1, hdCall2 ));

    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    pCall1 = m_H323CallTable[iIndex1];
    if( pCall1 != NULL )
    {
        pCall1 -> Lock();
        if( pCall1->GetCallHandle() != hdCall1 )
        {
            pCall1 -> Unlock();
            pCall1 = NULL;
        }
        else 
        {
            if( pCall2=m_H323CallTable[iIndex2] )
            {
                pCall2 -> Lock();
                if( pCall2->GetCallHandle() != hdCall2 )
                {
                    pCall2 -> Unlock();
                    pCall2 = NULL;
                    pCall1 -> Unlock();
                    pCall1 = NULL;
                }
            }
            else
            {
                pCall1 -> Unlock();
                pCall1 = NULL;
            }
        }
    }

    UnlockCallTable();

    *ppCall2 = pCall2;
    
    H323DBG(( DEBUG_LEVEL_TRACE, "Find2H323CallsAndLock exited:%lx:%lx.",
        hdCall1, hdCall2 ));
    return pCall1;
}


PH323_CALL 
CH323Line::FindH323CallAndLock (
    IN  HDRVCALL hdCall)
{
    H323DBG(( DEBUG_LEVEL_TRACE, "FindH323CallAndLock entered:%lx.", hdCall ));

    int iIndex = MakeCallIndex (hdCall);
    PH323_CALL  pCall = NULL;

    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    if( pCall=m_H323CallTable[iIndex] )
    {
        pCall -> Lock();
        if( pCall->GetCallHandle() != hdCall )
        {
            pCall -> Unlock();
            pCall = NULL;
        }
    }

    UnlockCallTable();

    H323DBG(( DEBUG_LEVEL_TRACE, "FindH323CallAndLock exited:%p.", pCall ));
    return pCall;
}


PH323_CALL 
CH323Line::FindCallByARQSeqNumAndLock( 
    WORD seqNumber
    )
{
    PH323_CALL  pCall = NULL;
    int         iIndex;

    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByARQSeqNumAndLock entered:%d.", 
        seqNumber ));
    
    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    for( iIndex=0; iIndex <  m_H323CallTable.GetAllocSize(); iIndex++ )
    {
        if( pCall=m_H323CallTable[iIndex] )
        {
            if( pCall->GetARQSeqNumber() == seqNumber )
            {
                pCall -> Lock();
                break;
            }
            pCall = NULL;
        }
    }

    UnlockCallTable();
    
    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByARQSeqNumAndLock exited." ));
    return pCall;
}


//the code is replicated for the purpose of effeciency
PH323_CALL 
CH323Line::FindCallByDRQSeqNumAndLock(
    WORD seqNumber
    )
{
    PH323_CALL  pCall = NULL;
    int         iIndex;

    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByDRQSeqNumAndLock entered:%d.",
        seqNumber ));
    
    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    for( iIndex=0; iIndex <  m_H323CallTable.GetAllocSize(); iIndex++ )
    {
        if( pCall=m_H323CallTable[iIndex] )
        {
            if( pCall->GetDRQSeqNumber() == seqNumber )
            {
                pCall -> Lock();
                break;
            }
            pCall = NULL;
        }
    }

    UnlockCallTable();
    
    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByDRQSeqNumAndLock exited:%d.",
        seqNumber ));
    return pCall;
}


//the code is replicated for the purpose of effeciency
PH323_CALL 
CH323Line::FindCallByCallRefAndLock( 
    WORD wCallRef
    )
{
    PH323_CALL  pCall = NULL;
    int         iIndex;

    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByCallRefAndLock entered:%d.",
        wCallRef ));
    
    wCallRef &= 0x7fff;
    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    for( iIndex=0; iIndex <  m_H323CallTable.GetAllocSize(); iIndex++ )
    {
        if( pCall=m_H323CallTable[iIndex] )
        {
            if( pCall->GetCallRef() == wCallRef )
            {
                pCall -> Lock();
                break;
            }
            pCall = NULL;
        }
    }

    UnlockCallTable();
    
    H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByCallRefAndLock exited:%d.",
        wCallRef ));
    
    return pCall;
}


void 
CH323Line::RemoveFromCTCallIdentityTable( 
    HDRVCALL hdCall )
{
    int iIndex;
    PCTCALLID_CONTEXT pCTCallIDContext = NULL;

    H323DBG(( DEBUG_LEVEL_TRACE, "RemoveFromCTCallIdentityTable entered:%lx.",
        hdCall ));
    
    m_CTCallIDTable.Lock();

    for( iIndex=0; iIndex <  m_CTCallIDTable.GetAllocSize(); iIndex++ )
    {
        pCTCallIDContext = m_CTCallIDTable[iIndex];

        if( pCTCallIDContext != NULL )
        {
            if( pCTCallIDContext -> hdCall == hdCall)
            {
                m_CTCallIDTable.RemoveAt(iIndex);
            }
        }
    }

    m_CTCallIDTable.Unlock();
        
    H323DBG(( DEBUG_LEVEL_TRACE, "RemoveFromCTCallIdentityTable exited:%lx.",
        hdCall ));
}


void 
CH323Line::ShutdownCTCallIDTable()
{
    int iIndex;
    PCTCALLID_CONTEXT pCTCallIDContext = NULL;

    H323DBG(( DEBUG_LEVEL_TRACE, "ShutdownCTCallIDTable entered." ));
    
    m_CTCallIDTable.Lock();

    for( iIndex=0; iIndex <  m_CTCallIDTable.GetAllocSize(); iIndex++ )
    {
        pCTCallIDContext = m_CTCallIDTable[iIndex];

        if( pCTCallIDContext != NULL )
        {
            delete pCTCallIDContext;
            m_CTCallIDTable[iIndex] = NULL;
        }
    }

    m_CTCallIDTable.Unlock();
    
    H323DBG(( DEBUG_LEVEL_TRACE, "ShutdownCTCallIDTable exited." ));
}


BOOL
CH323Line::CallReferenceDuped(
    WORD wCallRef
    )
{
    PH323_CALL  pCall = NULL;
    int         iIndex;

    H323DBG(( DEBUG_LEVEL_TRACE, "CallReferenceDuped entered:%d.", wCallRef ));
    
    wCallRef &= 0x7FFF;
    LockCallTable();

    for( iIndex=0; iIndex <  m_H323CallTable.GetAllocSize(); iIndex++ )
    {
        if( pCall=m_H323CallTable[iIndex] )
        {
            if( pCall->GetCallRef() == wCallRef )
            {
                UnlockCallTable();
                return TRUE;
            }
        }
    }

    UnlockCallTable();
    
    H323DBG(( DEBUG_LEVEL_TRACE, "CallReferenceDuped exited:%d.", wCallRef ));
    return FALSE;
}


HDRVCALL
CH323Line::GetCallFromCTCallIdentity( 
    int iCTCallID
    )
{
    int iIndex;
    PCTCALLID_CONTEXT pCTCallIDContext = NULL;

    H323DBG(( DEBUG_LEVEL_TRACE, "GetCallFromCTCallIdentity entered:%d.", 
        iCTCallID ));
    
    m_CTCallIDTable.Lock();

    for( iIndex=0; iIndex <  m_CTCallIDTable.GetAllocSize(); iIndex++ )
    {
        pCTCallIDContext = m_CTCallIDTable[iIndex];

        if( pCTCallIDContext != NULL )
        {
            if( pCTCallIDContext -> iCTCallIdentity == iCTCallID )
            {
                m_CTCallIDTable.Unlock();
                return (HDRVCALL)(pCTCallIDContext -> hdCall);
            }
        }
    }

    m_CTCallIDTable.Unlock();
        
    H323DBG(( DEBUG_LEVEL_TRACE, "GetCallFromCTCallIdentity exited:%d.",
        iCTCallID ));
    
    return NULL;
}


int
CH323Line::GetCTCallIdentity(
    IN  HDRVCALL    hdCall)
{
    int CTCallID = 0;
    int iIndex;
    PCTCALLID_CONTEXT pCTCallIDContext = NULL;
    
    H323DBG(( DEBUG_LEVEL_TRACE, "GetCTCallIdentity entered:%lx.",  hdCall ));

    m_CTCallIDTable.Lock();

    do
    {
        g_CTCallIdentity++;
        if( g_CTCallIdentity == 10000 )
        {
            g_CTCallIdentity = 1;
        }
    
        //lock the call so that nobody else would be able to delete the call
        for( iIndex=0; iIndex <  m_CTCallIDTable.GetAllocSize(); iIndex++ )
        {
            pCTCallIDContext = m_CTCallIDTable[iIndex] ;

            if( pCTCallIDContext != NULL )
            {
                if( pCTCallIDContext -> iCTCallIdentity == g_CTCallIdentity )
                {
                    break;
                }
            }
        }

        if( iIndex == m_CTCallIDTable.GetAllocSize() )
        {
            CTCallID = g_CTCallIdentity;
        }

    }while( CTCallID == 0 );

    pCTCallIDContext = new CTCALLID_CONTEXT;

    if( pCTCallIDContext == NULL )
    {
        m_CTCallIDTable.Unlock();
        return 0;
    }

    pCTCallIDContext->iCTCallIdentity = CTCallID;
    pCTCallIDContext->hdCall = hdCall;

    if( m_CTCallIDTable.Add(pCTCallIDContext) == -1 )
    {
        m_CTCallIDTable.Unlock();
        delete pCTCallIDContext;
        return 0;
    }

    m_CTCallIDTable.Unlock();
        
    H323DBG(( DEBUG_LEVEL_TRACE, "GetCTCallIdentity exited:%lx.",  hdCall ));
    
    return CTCallID;
}


void
CH323Line::SetCallForwardParams( 
    IN CALLFORWARDPARAMS* pCallForwardParams )
{
        
    H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams entered." ));
    
    if( m_pCallForwardParams != NULL )
    {
        FreeCallForwardParams( m_pCallForwardParams );
        m_pCallForwardParams = NULL;
    }
    m_pCallForwardParams = pCallForwardParams;

    H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams exited." ));
}


BOOL
CH323Line::SetCallForwardParams(
    IN LPFORWARDADDRESS pForwardAddress
    )
{
    H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams entered." ));
    
    if( m_pCallForwardParams != NULL )
    {
        pForwardAddress->next = m_pCallForwardParams->pForwardedAddresses;
        m_pCallForwardParams->pForwardedAddresses = pForwardAddress;
    }
    else
    {
        m_pCallForwardParams = new CALLFORWARDPARAMS;
        
        if( m_pCallForwardParams == NULL )
        {
            return FALSE;
        }

        ZeroMemory( m_pCallForwardParams, sizeof(CALLFORWARDPARAMS) );
        m_pCallForwardParams->fForwardingEnabled = TRUE;

        m_pCallForwardParams->pForwardedAddresses = pForwardAddress;
        pForwardAddress -> next = NULL;
    }


    //set unconditional forwarding
    m_pCallForwardParams->fForwardForAllOrigins = FALSE;
        
    H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams exited." ));
    
    return TRUE;
}



CH323Line::~CH323Line()
{
    if( m_dwInitState & LINEOBJECT_INITIALIZED )
    {
        DeleteCriticalSection (&m_CriticalSection);
    }
}


/*++

Routine Description:

    Hangs up call (if necessary) and closes call object.  

Arguments:

    Handle of the call.
Return Values:

    none.
    
--*/

void
CH323Line::H323ReleaseCall(
    IN HDRVCALL hdCall,
    IN DWORD dwDisconnectMode,
    IN WORD wCallReference
    )
{
    H323DBG(( DEBUG_LEVEL_TRACE, "H323ReleaseCall entered:%lx.", hdCall ));

    int         iIndex = MakeCallIndex (hdCall);
    PH323_CALL  pCall;
    BOOL        fDelete = FALSE;

    LockCallTable();
    
    //lock the call so that nobody else would be able to delete the call
    if( (pCall=m_H323CallTable[iIndex]) && (hdCall==pCall->GetCallHandle()) )
    {
        pCall -> Lock();
        
        if( (wCallReference != 0) && 
            (wCallReference != pCall->GetCallRef()) )
        {
            //This message is for some other call. Ignore the message.
            H323DBG(( DEBUG_LEVEL_VERBOSE, "TSPI_CLOSE_CALL message ignored."));
        }
        else
        {
            // drop call using normal disconnect code
            pCall -> DropCall( dwDisconnectMode );
            pCall -> Shutdown( &fDelete );

            H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx closed.", pCall ));
        }

        pCall -> Unlock();

        //release the H323 call object
        if( fDelete == TRUE )
        {
            H323DBG(( DEBUG_LEVEL_VERBOSE, "call delete:0x%08lx.", pCall ));
            delete pCall;
        }
    }
    
    UnlockCallTable();
    H323DBG(( DEBUG_LEVEL_TRACE, "H323ReleaseCall exited: %p.", pCall ));
}


BOOL 
CH323Line::Initialize ( 
    IN  DWORD   dwLineDeviceIDBase)
{
    DWORD dwSize;
    H323DBG((DEBUG_LEVEL_TRACE, "line Initialize entered."));

    if( m_dwInitState & LINEOBJECT_INITIALIZED )
    {
        return TRUE;
    }

    __try
    {
        if( !InitializeCriticalSectionAndSpinCount( &m_CriticalSection,
            0x80000000 ) )
        {
            return FALSE;
        }
    }
    __except( 1 )
    {
        return FALSE;
    }

    m_dwDeviceID = dwLineDeviceIDBase;
    m_dwInitState = LINEOBJECT_INITIALIZED;
    //m_dwMediaModes = H323_LINE_MEDIAMODES;
    m_hdLine = (HDRVLINE__ *)this;
    m_dwNumRingsNoAnswer = H323_NUMRINGS_NOANSWER;

    dwSize = sizeof( m_wszAddr );

    //create displayable address
    GetComputerNameW( m_wszAddr, &dwSize );

    H323DBG(( DEBUG_LEVEL_TRACE, "line %d initialized (addr=%S)(hdLine=%d).",
        m_dwDeviceID, m_wszAddr, m_hdLine));

    // change line device state to closed
    m_nState = H323_LINESTATE_NONE;

    //init the mSP handles list
    m_MSPHandleList = NULL;

    H323DBG(( DEBUG_LEVEL_TRACE, "line Initialize exited." ));
    // success
    return TRUE;
}


BOOL
CH323Line::AddMSPInstance( 
    HTAPIMSPLINE htMSPLine,
    HDRVMSPLINE  hdMSPLine )
{
    MSPHANDLEENTRY* pMSPHandleEntry;

    H323DBG(( DEBUG_LEVEL_TRACE, "AddMSPInstance entered." ));
    Lock();

    pMSPHandleEntry = new MSPHANDLEENTRY;

    if( pMSPHandleEntry == NULL )
    {
        Unlock();
        return FALSE;
    }

    pMSPHandleEntry->htMSPLine = htMSPLine;
    pMSPHandleEntry->hdMSPLine = hdMSPLine;
    pMSPHandleEntry->next = m_MSPHandleList;
    m_MSPHandleList = pMSPHandleEntry;

    Unlock();
    H323DBG(( DEBUG_LEVEL_TRACE, "AddMSPInstance exited." ));
    return TRUE;
}


BOOL
CH323Line::IsValidMSPHandle( 
    HDRVMSPLINE hdMSPLine,
    HTAPIMSPLINE* phtMSPLine )
{
    Lock();

    MSPHANDLEENTRY* pMSPHandle = m_MSPHandleList;
    while( pMSPHandle )
    {
        if( pMSPHandle->hdMSPLine == hdMSPLine )
        {
            *phtMSPLine = pMSPHandle->htMSPLine;
            Unlock();
            return TRUE;
        }
        pMSPHandle = pMSPHandle->next;
    }

    Unlock();
    return FALSE;
}


BOOL
CH323Line::DeleteMSPInstance( 
    HTAPIMSPLINE*   phtMSPLine,
    HDRVMSPLINE     hdMSPLine )
{
    MSPHANDLEENTRY* pMSPHandle;
    MSPHANDLEENTRY* pMSPHandleDel;
    BOOL            fRetVal = TRUE;

    H323DBG(( DEBUG_LEVEL_TRACE, "DeleteMSPInstance entered." ));
    Lock();

    if( m_MSPHandleList == NULL )
    {
        fRetVal = FALSE;
        goto func_exit;
    }

    if( m_MSPHandleList->hdMSPLine == hdMSPLine )
    {
        *phtMSPLine = m_MSPHandleList->htMSPLine;
        
        pMSPHandleDel = m_MSPHandleList;
        m_MSPHandleList = m_MSPHandleList->next;

        delete pMSPHandleDel;
        fRetVal = TRUE;
        goto func_exit;
    }

    for( pMSPHandle=m_MSPHandleList; pMSPHandle->next; pMSPHandle=pMSPHandle->next )
    {
        if( pMSPHandle->next->hdMSPLine == hdMSPLine )
        {
            *phtMSPLine = pMSPHandle->next->htMSPLine;
            
            pMSPHandleDel = pMSPHandle->next;
            pMSPHandle->next = pMSPHandle->next->next;
        
            delete pMSPHandleDel;
            fRetVal = TRUE;
            goto func_exit;
        }
    }

func_exit:
    Unlock();
    H323DBG(( DEBUG_LEVEL_TRACE, "DeleteMSPInstance exited." ));
    return fRetVal;
}


//!!always called in a lock
void 
CH323Line::ShutdownAllCalls(void)
{

    PH323_CALL pCall;
    H323_CONFERENCE* pConf;
    DWORD indexI;
    DWORD dwSize;
    BOOL fDelete = FALSE;

    if( !(m_dwInitState & LINEOBJECT_INITIALIZED) )
        return;

    H323DBG((DEBUG_LEVEL_TRACE, "ShutdownAllCalls entered."));
    
    if( m_dwInitState & LINEOBJECT_SHUTDOWN )
    {
        return;
    }

    //shutdown all calls, delete all calls
    LockCallTable();
    dwSize = m_H323CallTable.GetAllocSize();
    for( indexI=0; indexI <  dwSize; indexI++ )
    {
        pCall = m_H323CallTable[indexI];
        if( pCall != NULL )
        {
            pCall -> DropCall( 0 );
            pCall -> Shutdown(&fDelete);

            if(fDelete)
            {
                H323DBG((DEBUG_LEVEL_TRACE, "call delete:%p.", pCall ));
                delete pCall;
            }
        }

    }
    UnlockCallTable();

    dwSize = m_H323ConfTable.GetSize();
    for( indexI=0; indexI < dwSize; indexI++ )
    {
        pConf = m_H323ConfTable[indexI];
        //m_H323ConfTable.RemoveAt( indexI );
        if( pConf != NULL )
        {
            delete pConf;
            m_H323ConfTable[indexI] = NULL;
        }
    }

    H323DBG((DEBUG_LEVEL_TRACE, "ShutdownAllCalls exited."));
}


void
CH323Line::Shutdown(void)
{
    BOOL            fDelete = FALSE;
    MSPHANDLEENTRY* pMSPHandle;

    if( !(m_dwInitState & LINEOBJECT_INITIALIZED) )
    {
        return;
    }

    H323DBG((DEBUG_LEVEL_TRACE, "line Shutdown entered."));
    
    Lock();
    if( m_dwInitState & LINEOBJECT_SHUTDOWN )
    {
        Unlock();
        return;
    }

    FreeCallForwardParams( m_pCallForwardParams );
    m_pCallForwardParams = NULL;

    Close();

    m_dwMediaModes = NULL;
    //m_hdLine = NULL;
    m_hdNextMSPHandle = NULL;
    m_htLine = NULL;

    //Free the MSP handles list
    while( m_MSPHandleList )
    {
        pMSPHandle = m_MSPHandleList;
        m_MSPHandleList = m_MSPHandleList->next;
        delete pMSPHandle;
    }

    m_dwInitState |= LINEOBJECT_SHUTDOWN;

    Unlock();
    H323DBG(( DEBUG_LEVEL_TRACE, "line Shutdown exited." ));
}


LONG
CH323Line::CopyLineInfo(
    IN DWORD dwDeviceID,
    OUT LPLINEADDRESSCAPS pAddressCaps
    )
{
    DWORD dwAddressSize;
        
    H323DBG((DEBUG_LEVEL_TRACE, "line CopyLineInfo entered."));
    
    // determine size of address name
    dwAddressSize = H323SizeOfWSZ( m_wszAddr );

    // calculate number of bytes needed
    pAddressCaps->dwNeededSize = sizeof(LINEADDRESSCAPS) + 
                                 dwAddressSize
                                 ;

    // validate buffer allocated is large enough
    if (pAddressCaps->dwTotalSize >= pAddressCaps->dwNeededSize)
    {
        // record amount of memory used
        pAddressCaps->dwUsedSize = pAddressCaps->dwNeededSize;

        // position address name after fixed portion
        pAddressCaps->dwAddressSize = dwAddressSize;
        pAddressCaps->dwAddressOffset = sizeof(LINEADDRESSCAPS);
    
        // copy address name after fixed portion
        CopyMemory((LPBYTE)pAddressCaps + pAddressCaps->dwAddressOffset,
            (LPBYTE)m_wszAddr,
            pAddressCaps->dwAddressSize );
    }
    else if (pAddressCaps->dwTotalSize >= sizeof(LINEADDRESSCAPS))
    {
        H323DBG(( DEBUG_LEVEL_WARNING,
            "lineaddresscaps structure too small for strings." ));

        // record amount of memory used
        pAddressCaps->dwUsedSize = sizeof(LINEADDRESSCAPS);

    } 
    else 
    {
        H323DBG((DEBUG_LEVEL_ERROR, "lineaddresscaps structure too small."));

        // allocated structure too small 
        return LINEERR_STRUCTURETOOSMALL;
    }

    H323DBG(( DEBUG_LEVEL_VERBOSE, "addr 0 capabilities requested." ));
    
    // transfer associated device id 
    pAddressCaps->dwLineDeviceID = dwDeviceID;

    // initialize number of calls allowed per address 
    pAddressCaps->dwMaxNumActiveCalls = H323_MAXCALLSPERADDR;

    // initialize supported address capabilities
    pAddressCaps->dwAddressSharing     = H323_ADDR_ADDRESSSHARING;
    pAddressCaps->dwCallInfoStates     = H323_ADDR_CALLINFOSTATES;
    pAddressCaps->dwCallStates         = H323_ADDR_CALLSTATES;
    pAddressCaps->dwDisconnectModes    = H323_ADDR_DISCONNECTMODES;
    pAddressCaps->dwAddrCapFlags       = H323_ADDR_CAPFLAGS;
    pAddressCaps->dwCallFeatures       = H323_ADDR_CALLFEATURES;
    pAddressCaps->dwAddressFeatures    = H323_ADDR_ADDRFEATURES;
    pAddressCaps->dwCallerIDFlags      = H323_ADDR_CALLPARTYIDFLAGS;
    pAddressCaps->dwCalledIDFlags      = H323_ADDR_CALLPARTYIDFLAGS;

    // initialize unsupported address capabilities
    pAddressCaps->dwConnectedIDFlags   = LINECALLPARTYID_UNAVAIL;
    pAddressCaps->dwRedirectionIDFlags = LINECALLPARTYID_UNAVAIL;
    pAddressCaps->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
        
    H323DBG((DEBUG_LEVEL_TRACE, "line CopyLineInfo exited."));
    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetAddressCaps - Exited." ));
    // success
    return NOERROR;
}

        
/*++

Routine Description:

    Initiate activities on line device and allocate resources.

Arguments:

    htLine - TAPI's handle describing line device to open.

    dwTSPIVersion - The TSPI version negotiated through 
        TSPI_lineNegotiateTSPIVersion under which the Service Provider is 
        willing to operate.

Return Values:

    Returns true if successful.
    
--*/

LONG CH323Line::Open(
    IN  DWORD       DeviceID,
    IN  HTAPILINE   TapiLine,
    IN  DWORD       TspiVersion,
    IN  HDRVLINE *  ReturnDriverLine)
{
    HRESULT     hr;
    LONG        dwStatus = ERROR_SUCCESS;

    H323DBG(( DEBUG_LEVEL_TRACE, "H323 line open entered." ));

    if (GetDeviceID() != DeviceID)
    {
        // do not recognize device
        return LINEERR_BADDEVICEID; 
    }

    // make sure this is a version we support    
    if (!H323ValidateTSPIVersion (TspiVersion))
    {
        return LINEERR_INCOMPATIBLEAPIVERSION;
    }

    Lock();

    switch (m_nState)
    {

    case H323_LINESTATE_OPENED:
        H323DBG ((DEBUG_LEVEL_ERROR, 
            "H323 line is already open (H323_LINESTATE_OPENED), cannot reopen"));
        dwStatus = LINEERR_INUSE;
        break;

    case H323_LINESTATE_LISTENING:
        H323DBG ((DEBUG_LEVEL_ERROR, 
            "H323 line is already open (H323_LINESTATE_LISTENING), cannot reopen"));
        dwStatus = LINEERR_INUSE;
        break;

    case H323_LINESTATE_CLOSING:
        H323DBG ((DEBUG_LEVEL_ERROR, 
            "H323 line cannot be opened (H323_LINESTATE_CLOSING)"));
        dwStatus = LINEERR_INVALLINESTATE;
        break;

    case H323_LINESTATE_OPENING:
        H323DBG ((DEBUG_LEVEL_ERROR,
            "H323 line cannot be opened (H323_LINESTATE_OPENING)"));
        dwStatus = LINEERR_INVALLINESTATE;
        break;

    case H323_LINESTATE_NONE:
        // attempt to open line device

        H323DBG ((DEBUG_LEVEL_TRACE, "H323 line is opening"));

        // start listen if necessary
        if (IsMediaDetectionEnabled())
        {
            hr = Q931AcceptStart();
            if (hr == S_OK)
            {
                dwStatus = ERROR_SUCCESS;
                RasStart();
            }
            else
            {
                H323DBG ((DEBUG_LEVEL_ERROR, "failed to listen on Q.931"));
                dwStatus = LINEERR_OPERATIONFAILED;
            }
        }

        if (dwStatus == ERROR_SUCCESS)
        {
            H323DBG ((DEBUG_LEVEL_TRACE, "H323 line successfully opened"));

            // save line variables now
            m_nState = IsMediaDetectionEnabled()?
                H323_LINESTATE_LISTENING:H323_LINESTATE_OPENED;
            m_htLine = TapiLine;
            m_dwTSPIVersion = TspiVersion;
            *ReturnDriverLine = (HDRVLINE) this;
        }
        else
        {
            Q931AcceptStop();
        }
        break;

    default:
        _ASSERTE( FALSE );
    }

    Unlock();
    H323DBG(( DEBUG_LEVEL_TRACE, "H323 line open exited." ));
    return dwStatus;
}


/*++
Routine Description:

    Terminate activities on line device.

Arguments:

Return Values:

    Returns true if successful.

--*/
LONG
CH323Line::Close(void)
{
    LONG    dwStatus;

    H323DBG(( DEBUG_LEVEL_TRACE, "H323 line close entered." ));

    Lock();

    switch (m_nState)
    {
    case H323_LINESTATE_OPENED:
    case H323_LINESTATE_LISTENING: 

        if( m_fForwardConsultInProgress == TRUE )
        {
            H323DBG(( DEBUG_LEVEL_TRACE, "H323 line closed while forward is in progress." ));
            //Unlock();
            //return NOERROR;
        }

        // change line device state to closing
        m_nState = H323_LINESTATE_CLOSING;

        //shutdown all the calls
        ShutdownAllCalls();

        RasStop();

        if (IsMediaDetectionEnabled())
        {
            Q931AcceptStop();
        }
            
        ShutdownCTCallIDTable();

        // reset variables
        m_htLine = (HTAPILINE) NULL;
        m_dwTSPIVersion = 0;

        // change line device state to closed
        m_nState = H323_LINESTATE_NONE;
        dwStatus = ERROR_SUCCESS;
        break;

    default:
        H323DBG(( DEBUG_LEVEL_ERROR, 
            "H323: lineclose called in bogus state:%d", m_nState ));
        dwStatus = LINEERR_OPERATIONFAILED;
        break;
    }

    Unlock();
    H323DBG(( DEBUG_LEVEL_TRACE, "H323 line close exited." ));
    return dwStatus;
}


//                                                                           
// TSPI procedures                                                           
//                                                                           

        
/*++
Routine Description:

    This function closes the specified open line device after completing or 
    aborting all outstanding calls and asynchronous operations on the device.

    The Service Provider has the responsibility to (eventually) report 
    completion for every operation it decides to execute asynchronously.  
    If this procedure is called for a line on which there are outstanding 
    asynchronous operations, the operations should be reported complete with an
    appropriate result or error code before this procedure returns.  Generally
    the TAPI DLL would wait for these to complete in an orderly fashion.  
    However, the Service Provider should be prepared to handle an early call to
    TSPI_lineClose in "abort" or "emergency shutdown" situtations.

    A similar requirement exists for active calls on the line.  Such calls must 
    be dropped, with outstanding operations reported complete with appropriate 
    result or error codes.
    
    After this procedure returns the Service Provider must report no further 
    events on the line or calls that were on the line.  The Service Provider's 
    opaque handles for the line and calls on the line become "invalid".

    The Service Provider must relinquish non-sharable resources it reserves 
    while the line is open.  For example, closing a line accessed through a 
    comm port and modem should result in closing the comm port, making it once 
    available for use by other applications.

    This function is presumed to complete successfully and synchronously.

Arguments:

    hdLine - Specifies the Service Provider's opaque handle to the line to be
        closed.  After the line has been successfully closed, this handle is 
        no longer valid.

Return Values:

    Returns zero if the function is successful, or a negative error
    number if an error has occurred. Possible error returns are:

        LINEERR_INVALLINEHANDLE - The specified device handle is invalid.
        
        LINEERR_OPERATIONFAILED - The specified operation failed for unknown 
            reasons.

--*/
LONG
TSPIAPI
TSPI_lineClose (
    IN  HDRVLINE    DriverLine)
{
    _ASSERTE(DriverLine);
    _ASSERTE(DriverLine == (HDRVLINE) &g_H323Line);

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineClose - Entered." ));
    return ((CH323Line *) DriverLine) -> Close();
}


/*++
Routine Description:

    This function queries a specified line device to determine its telephony 
    capabilities. The returned information is valid for all addresses on the 
    line device.

    Line device ID numbering for a Service Provider is sequential from the 
    value set by the function TSPI_lineSetDeviceIDBase.

    The dwExtVersion field of pLineDevCaps has already been filled in to 
    indicate the version number of the Extension information requested.  If 
    it is zero, no Extension information is requested.  If it is non-zero it 
    holds a value that has already been negotiated for this device with the 
    function TSPI_lineNegotiateExtVersion.  The Service Provider should fill 
    in Extension information according to the Extension version specified.

    One of the fields in the LINEDEVCAPS structure returned by this function 
    contains the number of addresses assigned to the specified line device. 
    The actual address IDs used to reference individual addresses vary from 
    zero to one less than the returned number. The capabilities of each 
    address may be different. Use TSPI_lineGetAddressCaps for each available 
    <dwDeviceID, dwAddressID> combination to determine the exact capabilities 
    of each address.

Arguments:

    dwDeviceID - Specifies the line device to be queried.

    dwTSPIVersion - Specifies the negotiated TSPI version number.  This value 
        has already been negotiated for this device through the 
        TSPI_lineNegotiateTSPIVersion function.

    pLineDevCaps - Specifies a far pointer to a variable sized structure of 
        type LINEDEVCAPS. Upon successful completion of the request, this 
        structure is filled with line device capabilities information.

Return Values:

    Returns zero if the function is successful or a negative error
    number if an error has occurred. Possible error returns are:

        LINEERR_BADDEVICEID - The specified line device ID is out of range.

        LINEERR_INCOMPATIBLEAPIVERSION - The application requested an API 
            version or version range that is either incompatible or cannot 
            be supported by the Telephony API implementation and/or 
            corresponding service provider. 

        LINEERR_STRUCTURETOOSMALL - The dwTotalSize member of a structure 
            does not specify enough memory to contain the fixed portion of 
            the structure. The dwNeededSize field has been set to the amount 
            required.

--*/
LONG
TSPIAPI
TSPI_lineGetDevCaps(
    DWORD         dwDeviceID,
    DWORD         dwTSPIVersion,
    DWORD         dwExtVersion,
    LPLINEDEVCAPS pLineDevCaps
    )
{
    DWORD dwLineNameSize;
    DWORD dwProviderInfoSize;

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevCaps - Entered." ));

    if( g_pH323Line -> GetDeviceID() != dwDeviceID )
    {
        // do not recognize device
        return LINEERR_BADDEVICEID; 
    }

    // make sure this is a version we support
    if (!H323ValidateTSPIVersion(dwTSPIVersion))
    {
        // do not support tspi version
        return LINEERR_INCOMPATIBLEAPIVERSION;
    }

    // determine string lengths    
    dwProviderInfoSize  = H323SizeOfWSZ(g_pwszProviderInfo);
    dwLineNameSize      = H323SizeOfWSZ(g_pwszLineName);

    // calculate number of bytes required 
    pLineDevCaps->dwNeededSize = sizeof(LINEDEVCAPS) +
                                 dwProviderInfoSize  +
                                 dwLineNameSize     
                                 ;

    // make sure buffer is large enough for variable length data
    if (pLineDevCaps->dwTotalSize >= pLineDevCaps->dwNeededSize)
    {
        // record amount of memory used
        pLineDevCaps->dwUsedSize = pLineDevCaps->dwNeededSize;

        // position provider info after fixed portion
        pLineDevCaps->dwProviderInfoSize = dwProviderInfoSize;
        pLineDevCaps->dwProviderInfoOffset = sizeof(LINEDEVCAPS);

        // position line name after device class
        pLineDevCaps->dwLineNameSize = dwLineNameSize;
        pLineDevCaps->dwLineNameOffset = 
            pLineDevCaps->dwProviderInfoOffset +
            pLineDevCaps->dwProviderInfoSize
            ;

        // copy provider info after fixed portion
        CopyMemory((LPBYTE)pLineDevCaps + pLineDevCaps->dwProviderInfoOffset,
               (LPBYTE)g_pwszProviderInfo,
               pLineDevCaps->dwProviderInfoSize
               );
                
        // copy line name after device class
        CopyMemory((LPBYTE)pLineDevCaps + pLineDevCaps->dwLineNameOffset,
               (LPBYTE)g_pwszLineName,
               pLineDevCaps->dwLineNameSize
               );

    } 
    else if (pLineDevCaps->dwTotalSize >= sizeof(LINEDEVCAPS))
    {
        H323DBG(( DEBUG_LEVEL_WARNING,
            "linedevcaps structure too small for strings." ));

        // structure only contains fixed portion
        pLineDevCaps->dwUsedSize = sizeof(LINEDEVCAPS);

    } 
    else 
    {
        H323DBG(( DEBUG_LEVEL_WARNING, "linedevcaps structure too small." ));

        // structure is too small
        return LINEERR_STRUCTURETOOSMALL;
    }

    H323DBG(( DEBUG_LEVEL_VERBOSE, "line capabilities requested."));
    
    // construct permanent line identifier
    pLineDevCaps->dwPermanentLineID = (DWORD)MAKELONG(
        dwDeviceID - g_dwLineDeviceIDBase,
        g_dwPermanentProviderID
        );

    // notify tapi that strings returned are in unicode
    pLineDevCaps->dwStringFormat = STRINGFORMAT_UNICODE;

    // initialize line device capabilities
    pLineDevCaps->dwNumAddresses      = H323_MAXADDRSPERLINE;
    pLineDevCaps->dwMaxNumActiveCalls = H323_MAXCALLSPERLINE;
    pLineDevCaps->dwAddressModes      = H323_LINE_ADDRESSMODES;
    pLineDevCaps->dwBearerModes       = H323_LINE_BEARERMODES;
    pLineDevCaps->dwDevCapFlags       = H323_LINE_DEVCAPFLAGS;
    pLineDevCaps->dwLineFeatures      = H323_LINE_LINEFEATURES;
    pLineDevCaps->dwMaxRate           = H323_LINE_MAXRATE;
    pLineDevCaps->dwMediaModes        = H323_LINE_MEDIAMODES;
    pLineDevCaps->dwRingModes         = 0;

    // initialize address types to include phone numbers
    pLineDevCaps->dwAddressTypes = H323_LINE_ADDRESSTYPES;

    // line guid
    pLineDevCaps->PermanentLineGuid = LINE_H323;

    // modify GUID to be unique for each line
    pLineDevCaps->PermanentLineGuid.Data1 +=
        dwDeviceID - g_dwLineDeviceIDBase;

    // protocol guid
    pLineDevCaps->ProtocolGuid = TAPIPROTOCOL_H323;

    // add dtmf support via H.245 user input messages
    pLineDevCaps->dwGenerateDigitModes = LINEDIGITMODE_DTMF;
    pLineDevCaps->dwMonitorDigitModes  = LINEDIGITMODE_DTMF;

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevCaps - Exited." ));
    // success
    return NOERROR;
}

    
/*++
Routine Description:

    This operation enables the TAPI DLL to query the specified open line 
    device for its current status.

    The TAPI DLL uses TSPI_lineGetLineDevStatus to query the line device 
    for its current line status. This status information applies globally 
    to all addresses on the line device. Use TSPI_lineGetAddressStatus to 
    determine status information about a specific address on a line.

Arguments:

    hdLine - Specifies the Service Provider's opaque handle to the line 
        to be queried.

    pLineDevStatus - Specifies a far pointer to a variable sized data 
        structure of type LINEDEVSTATUS. Upon successful completion of 
        the request, this structure is filled with the line's device status.

Return Values:

    Returns zero if the function is successful or a negative error 
    number if an error has occurred. Possible error returns are:

        LINEERR_INVALLINEHANDLE - The specified line device handle is invalid.

        LINEERR_STRUCTURETOOSMALL - The dwTotalSize member of a structure does 
            not specify enough memory to contain the fixed portion of the 
            structure. The dwNeededSize field has been set to the amount 
            required.

--*/
LONG
TSPIAPI
TSPI_lineGetLineDevStatus(
    HDRVLINE        hdLine,
    LPLINEDEVSTATUS pLineDevStatus
    )
{
    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevStatus - Entered." ));

    if( hdLine != g_pH323Line -> GetHDLine() )
    {
        return LINEERR_INVALLINEHANDLE;
    }

    // determine number of bytes needed
    pLineDevStatus->dwNeededSize = sizeof(LINEDEVSTATUS);
    
    // see if allocated structure is large enough
    if (pLineDevStatus->dwTotalSize < pLineDevStatus->dwNeededSize)
    {
        H323DBG(( DEBUG_LEVEL_ERROR, "linedevstatus structure too small." ));

        // structure too small
        return LINEERR_STRUCTURETOOSMALL;
    }
    
    // record number of bytes used
    pLineDevStatus->dwUsedSize = pLineDevStatus->dwNeededSize;
    
    // initialize supported line device status fields
    pLineDevStatus->dwLineFeatures   = H323_LINE_LINEFEATURES;
    pLineDevStatus->dwDevStatusFlags = H323_LINE_DEVSTATUSFLAGS;

    // determine number of active calls on the line device
    pLineDevStatus -> dwNumActiveCalls = g_pH323Line -> GetNoOfCalls();

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevStatus - Exited." ));
    // success
    return NOERROR;
}


/*++
Routine Description:

    Retrieves the number of address IDs supported on the indicated line.

    This function is called by TAPI.DLL in response to an application calling
    lineSetNumRings, lineGetNumRings, or lineGetNewCalls. TAPI.DLL uses the 
    retrieved value to determine if the specified address ID is within the 
    range supported by the service provider.

Arguments:

    hdLine - Specifies the handle to the line for which the number of address 
        IDs is to be retrieved.

    pdwNumAddressIDs - Specifies a far pointer to a DWORD. The location is 
        filled with the number of address IDs supported on the indicated line. 
        The value should be one or larger.

Return Values:

    Returns zero if the function is successful, or a negative error number 
    if an error has occurred. Possible return values are as follows:

        LINEERR_INVALLINEHANDLE - The specified line device handle is invalid.

--*/
LONG
TSPIAPI
TSPI_lineGetNumAddressIDs(
    HDRVLINE hdLine,
    LPDWORD  pdwNumAddressIDs
    )
{
    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - Entered." ));

    if( hdLine != g_pH323Line -> GetHDLine() )
    {
        H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - bad linehandle:%lx, %lx.",
            hdLine, g_pH323Line -> GetHDLine() ));
        return LINEERR_INVALLINEHANDLE ;
    }

    // transfer number of addresses
    *pdwNumAddressIDs = H323_MAXADDRSPERLINE;

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - Exited." ));
    // success
    return NOERROR;
}

    
/*++

Routine Description:

    This function opens the line device whose device ID is given, returning 
    the Service Provider's opaque handle for the device and retaining the TAPI
    DLL's opaque handle for the device for use in subsequent calls to the 
    LINEEVENT procedure.

    Opening a line entitles the TAPI DLL to make further requests on the line.
    The line becomes "active" in the sense that the TAPI DLL can initiate 
    outbound calls and the Service Provider can report inbound calls.  The 
    Service Provider reserves whatever non-sharable resources are required to 
    manage the line.  For example, opening a line accessed through a comm port 
    and modem should result in opening the comm port, making it no longer 
    available for use by other applications.
    
    If the function is successful, both the TAPI DLL and the Service Provider 
    become committed to operating under the specified interface version number 
    for this open device.  Subsquent operations and events identified using 
    the exchanged opaque line handles conform to that interface version.  This 
    commitment and the validity of the handles remain in effect until the TAPI
    DLL closes the line using the TSPI_lineClose operation or the Service 
    Provider reports the LINE_CLOSE event.  If the function is not successful,
    no such commitment is made and the handles are not valid.

Arguments:

    dwDeviceID - Identifies the line device to be opened.  The value 
        LINE_MAPPER for a device ID is not permitted.

    htLine - Specifies the TAPI DLL's opaque handle for the line device to be 
        used in subsequent calls to the LINEEVENT callback procedure to 
        identify the device.

    phdLine - A far pointer to a HDRVLINE where the Service Provider fills in
        its opaque handle for the line device to be used by the TAPI DLL in 
        subsequent calls to identify the device.

    dwTSPIVersion - The TSPI version negotiated through 
        TSPI_lineNegotiateTSPIVersion under which the Service Provider is 
        willing to operate.

    pfnEventProc - A far pointer to the LINEEVENT callback procedure supplied
        by the TAPI DLL that the Service Provider will call to report 
        subsequent events on the line.

Return Values:

    Returns zero if the function is successful, or a negative error number 
    if an error has occurred. Possible return values are as follows:

        LINEERR_BADDEVICEID - The specified line device ID is out of range.

        LINEERR_INCOMPATIBLEAPIVERSION - The passed TSPI version or version 
            range did not match an interface version definition supported by 
            the service provider.

        LINEERR_INUSE - The line device is in use and cannot currently be 
            configured, allow a party to be added, allow a call to be 
            answered, or allow a call to be placed. 

        LINEERR_OPERATIONFAILED - The operation failed for an unspecified or 
            unknown reason. 

--*/
LONG
TSPIAPI
TSPI_lineOpen (
    IN  DWORD       DeviceID,
    IN  HTAPILINE   TapiLine,
    IN  LPHDRVLINE  ReturnDriverLine,
    IN  DWORD       TspiVersion,
    IN  LINEEVENT   pfnEventProc)
{
    return g_H323Line.Open (DeviceID, TapiLine, TspiVersion, ReturnDriverLine);
}


LONG
TSPIAPI
TSPI_lineCreateMSPInstance(
    HDRVLINE        hdLine,
    DWORD           dwAddressID,
    HTAPIMSPLINE    htMSPLine,
    LPHDRVMSPLINE   phdMSPLine
    )
{
    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCreateMSPInstance - Entered." ));

    if( hdLine != g_pH323Line -> GetHDLine() )
    {
        return LINEERR_RESOURCEUNAVAIL;
    }

    // We are not keeping the msp handles. Just fake a handle here.
    *phdMSPLine = g_pH323Line->GetNextMSPHandle();

    if( !g_pH323Line->AddMSPInstance( htMSPLine , *phdMSPLine ) )
    {
        return LINEERR_NOMEM;
    }
    
    H323DBG(( DEBUG_LEVEL_TRACE, "MSP instance created. hdMSP:%lx, htMSP:%lx.",
        *phdMSPLine, htMSPLine ));

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCreateMSPInstance - Exited." ));
    // success
    return NOERROR;
}


LONG
TSPIAPI
TSPI_lineCloseMSPInstance(
    HDRVMSPLINE hdMSPLine
    )
{
    HTAPIMSPLINE    htMSPLine;

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCloseMSPInstance - Entered." ));

    if( !g_pH323Line->DeleteMSPInstance( &htMSPLine , hdMSPLine ) )
    {
        return LINEERR_INVALPOINTER;
    }
    
    H323DBG(( DEBUG_LEVEL_TRACE, "MSP instance deleted. hdMSP:%lx, htMSP:%lx.",
        hdMSPLine, htMSPLine ));

    H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCloseMSPInstance - Exited." ));

    // success
    return NOERROR;
}