---

BgtRt.cpp

Go to the documentation of this file.

/*
 * BgtRt.cpp
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

#include <bogotel/Portability.h>
#include <bogotel/BgtRt.h>
#include <bogotel/VoiceDev.h>
#include <bogotel/SignalDev.h>
#include <bogotel/MsgTransport.h>
#include <bogotel/BgtErrors.h>
#include <bogotel/util.h>
#include <bogotel/Timer.h>

#include <io.h>
#include <stdexcept>

#include <cc_s7.h> // for S7_MAKECALL_BLK

namespace bogotel {

    const std::string CBgtRt::astrCcResultMsgs[1] = {
        "Unknown"
    };

    const std::string CBgtRt::astrGcResultMsgs[2] = {
        "Unknown",
        "NORMAL CLEARING"
    };

    const std::string CBgtRt::astrCcLibNames[1] = {
        "CC-Lib-name"
    };

    // Construction/Destruction

    CBgtRt::CBgtRt() :
    m_iGcResult(0),
    m_iCcLibId(0),
    m_lCcLibResult(0),
    m_lNextSignalHandle(1),
    m_lNextVoiceHandle(1001),
    m_lNextSCbusTimeslot(0),
    m_lMode(-1),
    m_hEvent(NULL),
    m_pQueue(NULL),
    m_pLatestEvt(NULL),
    m_pDlgHdlr(NULL)
    {
        g_util->init();

        int rc;
        if (CDevBase::m_pTransport == NULL) {
            CDevBase::m_pTransport = new CMsgTransport(this);
            if (CDevBase::m_pTransport == NULL) {
                g_util->log(3, -1, "new CMsgTransport failed.");
                throw std::runtime_error("new CMsgTransport failed.");
            }
            if ((rc = CDevBase::m_pTransport->init()) != resultSUCCESS) {
                g_util->log(3, -1, "CMsgTransport.init() failed. rc = %d", rc);
                throw std::runtime_error("CMsgTransport.init() failed");
            }
        }

        if (CDevBase::m_pTimer == NULL) {
            CDevBase::m_pTimer = new CTimer();
            if (CDevBase::m_pTimer == NULL) {
                g_util->log(3, -1, "new CTimer failed.");
                throw std::runtime_error("new CTimer failed.");
            }
        }

        m_pQueue = new CEvtQueue();
        if (m_pQueue == NULL) {
            g_util->log(3, -1, "new CEvtQueue failed.");
            throw std::runtime_error("new CEvtQueue failed.");
        }
        g_util->log(9, -1, "CBgtRt::CBgtRt() complete.", rc);
    }

    CBgtRt::~CBgtRt()
    {
        if (m_pQueue) {
            delete m_pQueue;
            m_pQueue = NULL;
        }
        if (m_pLatestEvt) {
            delete m_pLatestEvt;
            m_pLatestEvt = NULL;
        }
        if (CDevBase::m_pTransport) {
            delete CDevBase::m_pTransport;
            CDevBase::m_pTransport = NULL;
        }
        if (CDevBase::m_pTimer) {
            delete CDevBase::m_pTimer;
            CDevBase::m_pTimer = NULL;
        }
        if (m_pDlgHdlr) {
            delete m_pDlgHdlr;
            m_pDlgHdlr = NULL;
        }
    }

    CBgtRt* CBgtRt::_instance = 0;

    CBgtRt* CBgtRt::Instance() {

        if (_instance == 0) {
            _instance = new CBgtRt;
        }

        return _instance;

    } //Instance()

    int CBgtRt::addEvent(CEvt *pEvt)
    {
        int rc;

        if ((rc = m_pQueue->add(pEvt)) != resultSUCCESS) {
            g_util->log(3, -1, "m_pQueue->add() failed. rc = %d", rc);
            return rc;
        }

        if (m_hEvent) {
            ::SetEvent(m_hEvent);
        }
        g_util->log(9, -1, "CBgtRt.addEvent() complete.", rc);
        return resultSUCCESS;
    }

    int CBgtRt::waitEvent(long lTimeout, long *plRemaining)
    {
        int rc;
        CEvt* pEvt = NULL;

        (*plRemaining) = 0; 

        if ((rc = m_pQueue->wait(lTimeout, &pEvt)) != resultSUCCESS) {
            g_util->log(3, -1, "m_pQueue->wait() failed. rc = %d", rc);
            return rc;
        }

        if (pEvt && pEvt->m_iSysType == CEvt::SysType::DISABLE_HANDLER) {
            // don't touch the last event just disable the event handler
            delete pEvt;
            return resultDISABLE;
        }

        // get rid of old event
        if (m_pLatestEvt) {
            delete m_pLatestEvt;
            m_pLatestEvt = NULL;
        }

        if (pEvt == NULL) {
            (*plRemaining) = -1;
    //      g_util->log(9, -1, "CBgtRt.waitEvent() complete. No event pending.");
            return resultSUCCESS;
        }

        // save new event
        m_pLatestEvt = pEvt;

        g_util->log(9, -1, "CBgtRt.waitEvent() complete. Event pending.");

        return resultSUCCESS;
    }

    int CBgtRt::incomingMsg(CMsg *pMsg)
    {
        int rc;
        switch (pMsg->m_class) {
        case MC_SIGNAL: {
            // find the signalling device based on the ID
            MAP_LONG2PTR::iterator itL2P;
            itL2P = m_mapSignalDev.find(pMsg->m_id);
            if (itL2P == m_mapSignalDev.end()) {
                g_util->log(3, -1, "signal handle not found in BgtRt.incomingMsg. handle is %d", pMsg->m_id);
                return resultFUNC_BAD_PARAMETER;
            }
            CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);
            if ((rc = pSig->receiveMsg(pMsg)) != resultSUCCESS) {
                g_util->log(3, pMsg->m_id, "CBgtRt::incomingMsg(): CSignalDev::receiveMsg() failed. rc is %d", rc);
            }
            g_util->log(9, pMsg->m_id, "CBgtRt::incomingMsg() complete. Signal dev Msg handled.");
            return rc;
                                 }
        case MC_VOICE: {
            // get voice dev with handle supplied
            MAP_LONG2PTR::iterator itL2P;
            itL2P = m_mapVoiceDev.find(pMsg->m_id);
            if (itL2P == m_mapVoiceDev.end()) {
                g_util->log(3, -1, "voice handle not found in BgtRt.incomingMsg. handle is %d", pMsg->m_id);
                return resultFUNC_BAD_PARAMETER;
            }
            CVoiceDev *pVoice = reinterpret_cast<CVoiceDev *>(itL2P->second);
            if ((rc = pVoice->receiveMsg(pMsg)) != resultSUCCESS) {
                g_util->log(3, pVoice->getSignalHandle(), "CBgtRt::incomingMsg(): CVoiceDev::receiveMsg() failed. rc is %d", rc);
            }
            g_util->log(9, pVoice->getSignalHandle(), "CBgtRt::incomingMsg() complete. Voice dev Msg handled.");
            return rc;
                                     }
        }
        return resultSUCCESS;
    }

    int CBgtRt::enableHandler(long dev, unsigned long event_type, CDlgEvtHdlr::ptr_evt_hndlr hdlr)
    {
        char _func[] = "CBgtRt::enableHandler";
        // currently, the handler must enabled for all devices and all event types
        if (dev != EV_ANYDEV) {
            g_util->log(3, -1, "Invalid dev mask in %s. Mask is %xl", _func, dev);
            return resultFUNC_BAD_PARAMETER;
        }
        if (event_type != EV_ANYEVT) {
            g_util->log(3, -1, "Invalid event type mask in %s. Mask is %xl", _func, event_type);
            return resultFUNC_BAD_PARAMETER;
        }
        if (hdlr == NULL) {
            g_util->log(3, -1, "Null pointer received in %s.", _func);
            return resultFUNC_BAD_PARAMETER;
        }

        // initialize event handler model class
        m_pDlgHdlr = new CDlgEvtHdlr(hdlr);

        return resultSUCCESS;
    }

    int CBgtRt::disableHandler(long dev, unsigned long event_type, CDlgEvtHdlr::ptr_evt_hndlr hdlr)
    {
        char _func[] = "CBgtRt::disableHandler";

        // check to make sure this is the same handler as was enabled previously
        if (m_pDlgHdlr == NULL) {
            g_util->log(3, -1, "%s: No handler enabled.", _func);
            return resultUNEXPECTED;
        }
        if (dev != EV_ANYDEV) {
            g_util->log(3, -1, "Invalid dev mask in %s. Mask is %xl", _func, dev);
            return resultFUNC_BAD_PARAMETER;
        }
        if (event_type != EV_ANYEVT) {
            g_util->log(3, -1, "Invalid event type mask in %s. Mask is %xl", _func, event_type);
            return resultFUNC_BAD_PARAMETER;
        }
        if (! m_pDlgHdlr->matchesHandler(hdlr)) {
            g_util->log(3, -1, "%s: Handler to disable doesn't match current handler.", _func);
            return resultFUNC_BAD_PARAMETER;
        }

        delete m_pDlgHdlr;
        m_pDlgHdlr = NULL;

        return resultSUCCESS;
    }

    int CBgtRt::getEvtDevHandle(unsigned long evt_handle, long *plHandle)
    {
        char _func[] = "CBgtRt::getEvtDevHandle";
        if (m_pLatestEvt == NULL) {
            g_util->log(3, -1, "%s called when no event is pending", _func);
            return resultPOINTER;
        }
        // we have to figure out what type of event we have (signal or voice)
        if (m_pLatestEvt->m_lType & DT_GC) {
            // it's a GC event -- return signal handle
            (*plHandle) = m_pLatestEvt->m_lSignalDevHandle;
        } else {
            // it's not a GC event -- assume voice event
            (*plHandle) = m_pLatestEvt->m_lVoiceDevHandle;
        }
        
    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "%s complete.", _func);
        return resultSUCCESS;
    }

    int CBgtRt::getEvtVoiceDevHandle(unsigned long evt_handle, long *plHandle)
    {
        if (m_pLatestEvt == NULL) {
            g_util->log(3, -1, "BgtRt::getEvtVoiceDevHandle called when no event is pending");
            return resultPOINTER;
        }
        (*plHandle) = m_pLatestEvt->m_lVoiceDevHandle;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtVoiceDevHandle() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::getEvtSignalDevHandle(unsigned long evt_handle, long *plHandle)
    {
        if (m_pLatestEvt == NULL) {
            g_util->log(3, -1, "BgtRt::getEvtSignalDevHandle called when no event is pending");
            return resultPOINTER;
        }
        (*plHandle) = m_pLatestEvt->m_lSignalDevHandle;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtSignalDevHandle() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::putEvt(long hSignal, unsigned long event_type, long len, void *pData, long err)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in BgtRt.putEvt(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }

        CSignalDev *pSig = reinterpret_cast<CSignalDev*>(itL2P->second);
        pSig->putEvt(event_type, len, pData, err);

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::putEvt() complete.");
        return resultSUCCESS;
    }


    int CBgtRt::getEvtType(unsigned long evt_handle, long *plType)
    {
        if (m_pLatestEvt == NULL) {
            // return 0 to indicate that there is no event here
            (*plType) = 0;
            g_util->log(9, -1, "BgtRt::getEvtType() complete. no event pending.");
            return resultSUCCESS;
        }
        (*plType) = m_pLatestEvt->m_lType;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtType() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::getEvtFlags(unsigned long *pulFlags)
    {
        if (m_pLatestEvt == NULL) {
            g_util->log(3, -1, "BgtRt::getEvtFlags called when no event is pending");
            return resultPOINTER;
        }
        (*pulFlags) = m_pLatestEvt->m_ulFlags;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtFlags() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::getEvtCrn(CRN *pCrn)
    {
        if (m_pLatestEvt == NULL) {
            g_util->log(9, -1, "BgtRt::getEvtCrn called when no event is pending");
            return resultPOINTER;
        }
        (*pCrn) = m_pLatestEvt->m_lCrn;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtCrn() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::getEvtUsrAttr(unsigned long evt_handle, void **ppUsrAttr)
    {
        if (m_pLatestEvt == NULL) {
            g_util->log(3, -1, "BgtRt::getEvtUsrAttr called when no event is pending");
            return resultPOINTER;
        }
        (*ppUsrAttr) = m_pLatestEvt->m_pUsrAttr;

    //  g_util->log(9, m_pLatestEvt->m_lSignalDevHandle, "BgtRt::getEvtUsrAttr() complete.");
        return resultSUCCESS;
    }

    int CBgtRt::getUsrAttr(LINEDEV hSignal, void **ppUsrData)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in BgtRt.getUsrAttr(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }

        *(ppUsrData) = (reinterpret_cast <CSignalDev*>(itL2P->second))->getUsrAttr();
    //  g_util->log(9, hSignal, "BgtRt::getUsrAttr() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::setMode(long parmid, void *hEvent)
    {
        if (hEvent) {
            m_hEvent = reinterpret_cast<HANDLE>(hEvent);
        }
        m_lMode = parmid;
        return resultSUCCESS;
    }

    int CBgtRt::resetLineDev(LINEDEV hSignal, unsigned long ulMode)
    {
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in CBgtRt::resetLineDev(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }

        CSignalDev *pSig = reinterpret_cast <CSignalDev*>(itL2P->second);
        int rc;
        if ((rc = pSig->resetLineDev()) != resultSUCCESS) {
            g_util->log(3, hSignal, "CSigDev.resetLineDev() failed in BgtRt.resetLineDev(). rc is %d", rc);
            return rc;
        }
        g_util->log(9, hSignal, "CBgtRt::resetLineDev() completed.");
        return rc;
    }

    int CBgtRt::waitCall(LINEDEV hSignal, CRN *pCrn, int iTimeout, unsigned long ulMode)
    {
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in BgtRt.waitCall(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->waitCall()) != resultSUCCESS) {
            g_util->log(3, hSignal, "CSigDev.waitCall() failed in BgtRt.waitCall(). rc is %d", rc);
            return rc;
        }
        g_util->log(9, hSignal, "BgtRt::waitCall() completed.");
        return rc;
    }

    int CBgtRt::makeCall(LINEDEV hSignal, CRN *pCrn, char *szNumber, GC_MAKECALL_BLK *pMakecall, 
                               int iTimeout, unsigned long ulMode)
    {
        char _func[] = "CBgtRt::makeCall";
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in BgtRt.makeCall(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        char *pAni = NULL;
        // check if we a makecall block
        if (pMakecall) {
            if (pMakecall->cclib) {
                try {
                    S7_MAKECALL_BLK *block = (S7_MAKECALL_BLK *)pMakecall->cclib;
                    pAni = block->ss7.origination_phone_number;
                } catch (...) {
                    g_util->log(3, hSignal, "%s: Failed to cast cclib to S7_MAKECALL_BLK", _func);
                }
            } else {
                g_util->log(3, hSignal, "%s: cclib NULL in pMakecall", _func);
                return resultFUNC_BAD_PARAMETER;
            }
        }
        if ((rc = pSig->makeCall(pCrn, szNumber, iTimeout, pAni)) != resultSUCCESS) {
            g_util->log(3, hSignal, "CSigDev.makeCall() failed in BgtRt.makeCall(). rc is %d", rc);
            return rc;
        }

        // save the device under the CRN
        m_mapCrn2SignalDev.insert(MAP_LONG2PTR::value_type((*pCrn), pSig));

        g_util->log(9, hSignal, "BgtRt::makeCall() completed.");
        return resultSUCCESS;
    }

    // registers SignalDev instance under the CRN specified
    int CBgtRt::registerCrn(CSignalDev *pSig, CRN crn)
    {
        // check if the CRN is already stored in the map
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P != m_mapCrn2SignalDev.end()) {
            // the CRN is already stored in the map
            g_util->log(3, pSig->getHandle(), "CRN is already stored in the map. CRN is %d", crn);
        }

        // save the device under the CRN
        m_mapCrn2SignalDev.insert(MAP_LONG2PTR::value_type(crn, pSig));
        
        g_util->log(9, pSig->getHandle(), "BgtRt.registerCrn() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::deregisterCrn(CRN crn)
    {
        // remove the CRN from the map
        m_mapCrn2SignalDev.erase(crn);
        
        g_util->log(9, -1, "BgtRt.deregisterCrn() completed.");

        return resultSUCCESS;
    }

    int CBgtRt::getDnis(CRN crn, char *szDnis)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "CRN not found in BgtRt.getDnis(). crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        pSig->getDnis(szDnis);

        g_util->log(9, pSig->getHandle(), "BgtRt::getDnis() completed. DNIS is %s", szDnis);
        return resultSUCCESS;
    }

    int CBgtRt::getAni(CRN crn, char *szAni)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "CRN not found in BgtRt.getAni(). crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        pSig->getAni(szAni);

        g_util->log(9, pSig->getHandle(), "BgtRt.getAni() completed. ANI is %s", szAni);
        return resultSUCCESS;
    }

    int CBgtRt::setCallingNum(LINEDEV hSignal, char *szCallingNum)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "Signal handle not found in BgtRt::setCallingNum(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        pSig->setAni(szCallingNum);

        g_util->log(9, pSig->getHandle(), "BgtRt::setCallingNum() completed. calling num is %s", szCallingNum);
        return resultSUCCESS;
    }

    int CBgtRt::openVoiceDev(int *piHandle, const char *szName)
    {
        SET_STRING::iterator itString;

        // first check if this device has already been opened
        std::string strName = szName;
        itString = m_setVoiceDevNames.find(strName);
        if (itString != m_setVoiceDevNames.end()) {
            g_util->log(3, -1, "voice dev already opened in CBgtRt::openVoiceDev(). voice name is %s", szName);
            return resultFUNC_BAD_PARAMETER;
        }

        // add the device name to the set
        m_setVoiceDevNames.insert(strName);

        CVoiceDev *pVD = (CVoiceDev *)new CVoiceDev(this);
        if (pVD == NULL) {
            g_util->log(3, -1, "new CVoiceDev failed.");
            return resultNOTENOUGHMEMORY;
        }

        int rc;
        if ((rc = pVD->init(strName, m_lNextVoiceHandle, m_lNextSCbusTimeslot)) != resultSUCCESS) {
            g_util->log(3, -1, "CVoiceDev::init() failed in CBgtRt::openVoiceDev(). voice name is %s", szName);
            return rc;
        }

        m_mapVoiceDev.insert(MAP_LONG2PTR::value_type(m_lNextVoiceHandle,pVD));
        m_mapScTsVoiceDev.insert(MAP_LONG2PTR::value_type(m_lNextSCbusTimeslot,pVD));
        (*piHandle) = m_lNextVoiceHandle;

        m_lNextVoiceHandle++;
        m_lNextSCbusTimeslot++;

        g_util->log(9, -1, "BgtRt.openVoiceDev() completed. voice dev is %s", szName);
        return resultSUCCESS;
    }

    int CBgtRt::openSignalDev(LINEDEV *pHandle, char *szName, void *pUsrattr)
    {
        SET_STRING::iterator itString;
        std::string strProt;
        std::string strNetDev;
        std::string strVoxDev;
        char *szToken;

        // separate the different portions of the device name
        szToken = strtok(szName, ":");
        // the format for the string is ":<key>_<name>"
        while(szToken != NULL) {
            switch (szToken[0]) {
            case 'P':
                strProt = &szToken[2];
                break;
            case 'N':
                strNetDev = &szToken[2];
                break;
            case 'V':
                // we will parse the voice name but not use it
                // @todo use voice device name
                strVoxDev = &szToken[2];
                break;
            default:
                // unknown field
                return resultFUNC_BAD_PARAMETER;
            }
            szToken = strtok(NULL, ":");
        }
        
        // check if we've already been asked to open this network device
        itString = m_setSignalDevNames.find(strNetDev);
        if (itString != m_setSignalDevNames.end()) {
            g_util->log(3, -1, "signal dev already opened in CBgtRt::openSignalDev(). signal name is %s", szName);
            return resultFUNC_BAD_PARAMETER;
        }

        // add the device name to the set
        m_setSignalDevNames.insert(strNetDev);

        CSignalDev *pSD = (CSignalDev *)new CSignalDev(this);
        if (pSD== NULL) {
            g_util->log(3, -1, "new CSignalDev failed.");
            return resultNOTENOUGHMEMORY;
        }

        int rc;
        if ((rc = pSD->init(strNetDev, strProt, pUsrattr, m_lNextSignalHandle, m_lNextSCbusTimeslot)) != resultSUCCESS) {
            g_util->log(3, -1, "CSignalDev::init() failed in CBgtRt::openSignalDev(). voice name is %s", szName);
            return rc;
        }

        m_mapSignalDev.insert(MAP_LONG2PTR::value_type(m_lNextSignalHandle,pSD));
        m_mapScTsSignalDev.insert(MAP_LONG2PTR::value_type(m_lNextSCbusTimeslot,pSD));
        (*pHandle) = m_lNextSignalHandle;
        
        m_lNextSignalHandle++;
        m_lNextSCbusTimeslot++;

        g_util->log(9, pSD->getHandle(), "BgtRt.openSignalDev() completed. voice dev is %s", szName);
        return resultSUCCESS;
    }

    int CBgtRt::getVoiceTimeslot(int iVoiceHandle, long *plTimeslot)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "voice handle not found in BgtRt.getVoiceTimeslot(). handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        (*plTimeslot) = ((CVoiceDev*)itL2P->second)->getTimeslot();
        g_util->log(9, -1, "BgtRt::getVoiceTimeslot() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::getSignalTimeslot(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        // get SignalDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, -1, "signal handle not found in BgtRt.getSignalTimeslot(). handle is %d", hSignal);
            return resultFUNC_BAD_PARAMETER;
        }

        pScTsInfo->sc_tsarrayp[0] = ((CSignalDev*)itL2P->second)->getTimeslot();
        g_util->log(9, ((CSignalDev*)itL2P->second)->getHandle(), "BgtRt::getSignalTimeslot() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::listenVoiceTimeslot(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        CVoiceDev *pVD;
        CSignalDev *pSD;

        // get VoiceDev with timeslot handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapScTsVoiceDev.find(pScTsInfo->sc_tsarrayp[0]);
        if (itL2P == m_mapScTsVoiceDev.end()) {
            g_util->log(3, hSignal, "signal handle not found in BgtRt.listenVoiceTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }
        try {
            pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);
        } catch (...) {
            g_util->log(3, hSignal, "invalid handle in BgtRt.listenVoiceTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with hande supplied
        itL2P = m_mapSignalDev.find(hSignal);
        if (itL2P == m_mapSignalDev.end()) {
            g_util->log(3, hSignal, "signal dev not found in BgtRt.listenVoiceTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }

        pSD = reinterpret_cast<CSignalDev*>(itL2P->second);

        pSD->listen(pVD);

        g_util->log(9, pSD->getHandle(), "BgtRt::listenVoiceTimeslot() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::listenSignalTimeslot(LINEDEV lVoiceHandle, long lTimeslot)
    {
        CSignalDev *pSD;
        CVoiceDev *pVD;

        // get SignalDev with timeslot handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapScTsSignalDev.find(lTimeslot);
        if (itL2P == m_mapScTsSignalDev.end()) {
            g_util->log(3, -1, "signal dev not found in BgtRt.listenSignalTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }
        try {
            pSD = reinterpret_cast<CSignalDev*>(itL2P->second);
        } catch (...) {
            g_util->log(3, -1, "invalid handle in BgtRt.listenSignalTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }

        // get VoiceDev with handle supplied
        itL2P = m_mapVoiceDev.find(lVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "voice handle not found in BgtRt.listenSignalTimeslot()");
            return resultFUNC_BAD_PARAMETER;
        }

        pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        pVD->listen(pSD);

        g_util->log(9, pSD->getHandle(), "BgtRt::listenSignalTimeslot() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::acceptCall(CRN crn, int iRings, unsigned long ulMode)
    {
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with CRN supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "CRN not found in BgtRt.acceptCall(). crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->acceptCall(crn)) != resultSUCCESS) {
            g_util->log(3, pSig->getHandle(), "CSigDev->acceptCall failed in BgtRt.acceptCall(). rc is %d", rc);
            return rc;
        }
        g_util->log(9, pSig->getHandle(), "BgtRt::acceptCall() completed.");
        return rc;
    }

    int CBgtRt::answerCall(CRN crn, int iRings, unsigned long ulMode)
    {
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with CRN supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "CRN not found in BgtRt.answerCall(). crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->answerCall(crn)) != resultSUCCESS) {
            g_util->log(3, pSig->getHandle(), "CSigDev->answerCall failed in BgtRt.answerCall(). rc is %d", rc);
            return rc;
        }
        g_util->log(9, pSig->getHandle(), "BgtRt::answerCall() completed.");
        return rc;
    }

    int CBgtRt::dropCall(CRN crn, int iCause, unsigned long ulMode)
    {
        // we only work in asyncronous mode
        if (ulMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        // get SignalDev with CRN supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "BgtRt::dropCall(): crn not found. crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->dropCall(crn, iCause)) != resultSUCCESS) {
            g_util->log(3, pSig->getHandle(), "BgtRt::dropCall(): CSignalDev::dropCall failed. rc is %d", rc);
            return rc;
        }
        g_util->log(9, pSig->getHandle(), "BgtRt::dropCall() completed.");
        return rc;
    }

    int CBgtRt::releaseCall(CRN crn, unsigned long ulMode)
    {
        // get SignalDev with CRN supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "BgtRt::releaseCall(): crn not found. crn is %d", crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->releaseCall(crn, ulMode)) != resultSUCCESS) {
            g_util->log(3, pSig->getHandle(), "BgtRt::releaseCall(): CSignalDev::releaseCall failed. rc is %d", rc);
            return rc;
        }
        g_util->log(9, pSig->getHandle(), "BgtRt::releaseCall() completed.");
        return rc;
    }

    int CBgtRt::resultValue(METAEVENT *pMetaEvent, int *piGcResult, int *pCcLibId, long *pCcLibResult)
    {
        // get SignalDev with CRN from metaevent
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapCrn2SignalDev.find(pMetaEvent->crn);
        if (itL2P == m_mapCrn2SignalDev.end()) {
            g_util->log(3, -1, "BgtRt::resultValue(): crn not found. crn is %d", pMetaEvent->crn);
            return resultFUNC_BAD_PARAMETER;
        }
        CSignalDev *pSig = reinterpret_cast<CSignalDev *>(itL2P->second);

        int rc;
        if ((rc = pSig->resultValue(pMetaEvent, piGcResult, pCcLibId, pCcLibResult)) != resultSUCCESS) {
            g_util->log(3, pSig->getHandle(), "BgtRt::resultValue(): CSignalDev::resultValue failed. rc is %d", rc);
            return rc;
        }
        g_util->log(9, pSig->getHandle(), "BgtRt::resultValue() completed.");
        return rc;
    }

    int CBgtRt::errorValue(int *piGcResult, int *piCcLibId, long *plCcLibResult)
    {
        (*piGcResult)    = m_iGcResult;
        (*piCcLibId)     = m_iCcLibId;
        (*plCcLibResult) = m_lCcLibResult;

        // we'll be simplistic here and assume that if the values have been read,
        // we can reset them
        m_iGcResult    = 0;
        m_iCcLibId     = 0;
        m_lCcLibResult = 0;

        return resultSUCCESS;
    }

    int CBgtRt::mediaFileOpen(int *piHandle, const char *szFilename, int iFlags)
    {
        if (((*piHandle) = _open(szFilename, iFlags)) == -1) {
            return resultIOERROR;
        }

        // Store the handle along with the filename
        // We'll defer getting more info about the WAV for until it is played;
        // after all, we don't know if it will be played.
        std::string str = szFilename;

        {
            boost::mutex::scoped_lock lock(m_mtxFilenameMap);
            CVoiceDev::s_mapHandle2Filename.insert(MAP_INT2STR::value_type((*piHandle), str));
        }

        return resultSUCCESS;
    }

    int CBgtRt::mediaFileClose(int iHandle)
    {
        {
            boost::mutex::scoped_lock lock(m_mtxFilenameMap);
            CVoiceDev::s_mapHandle2Filename.erase(iHandle);
        }

        if (_close(iHandle) == -1) {
            return resultIOERROR;
        }
        return resultSUCCESS;
    }

    int CBgtRt::mediaFilePlay(int iVoiceHandle,DX_IOTT *pIott,const DV_TPT *pTpt,const DX_XPB *pXpb,unsigned short usMode)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "voice handle not found in BgtRt.mediaFilePlay(). handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        int rc;
        if ((rc = pVD->play(pIott,pTpt,pXpb,usMode)) != resultSUCCESS) {
            g_util->log(3, -1, "BgtRt::mediaFilePlay(): CVoiceDev::play() failed. rc is %d", rc);
            return rc;
        }

        g_util->log(9, -1, "BgtRt::mediaFilePlay() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::stopVoice(int iVoiceHandle, unsigned short usMode)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "CBgtRt::stopVoice(): voice handle not found. handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        int rc;
        if ((rc = pVD->stop(usMode)) != resultSUCCESS) {
            g_util->log(3, -1, "CBgtRt::stopVoice(): CVoiceDev::stop() failed. rc is %d", rc);
            return rc;
        }

        g_util->log(9, -1, "BgtRt::stopVoice() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::clearDigitBuffer(int iVoiceHandle)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "CBgtRt::clearDigitBuffer(): voice handle not found. handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        int rc;
        if ((rc = pVD->clearDigitBuffer()) != resultSUCCESS) {
            g_util->log(3, -1, "CBgtRt::clearDigitBuffer(): CVoiceDev::clearDigitBuffer() failed. rc is %d", rc);
            return rc;
        }

        g_util->log(9, -1, "CBgtRt::clearDigitBuffer() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::getDigit(int iVoiceHandle, const DV_TPT *pTpt, DV_DIGIT *pDigit, unsigned short usMode)
    {
        char method[] = "CBgtRt::getDigit";
        g_util->log(9, -1, "%s: Entered", method);

        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "CBgtRt::getDigit(): voice handle not found. handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        int rc;

        memset(pDigit, 0, sizeof(DV_DIGIT));

        if ((rc = pVD->getDigit(pTpt, pDigit, usMode)) != resultSUCCESS) {
            g_util->log(3, -1, "CBgtRt::getDigit(): CVoiceDev::getDigit() failed. rc is %d", rc);
            return rc;
        }

        g_util->log(9, -1, "%s: Completed", method);
        return resultSUCCESS;
    }

    int CBgtRt::dial(int iHandle, const char *szDialStr, const DX_CAP *pCAP, unsigned short usMode)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "CBgtRt::dial(): voice handle not found. handle is %d", iHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        int rc;

        if ((rc = pVD->dial(szDialStr, pCAP, usMode)) != resultSUCCESS) {
            g_util->log(3, -1, "CBgtRt::dial(): CVoiceDev::dial() failed. rc is %d", rc);
            return rc;
        }

        g_util->log(9, -1, "CBgtRt::dial() completed.");
        return resultSUCCESS;
    }

    int CBgtRt::getTermMsk(INT iVoiceHandle, long *lMask)
    {
        // get VoiceDev with handle supplied
        MAP_LONG2PTR::iterator itL2P;
        itL2P = m_mapVoiceDev.find((long)iVoiceHandle);
        if (itL2P == m_mapVoiceDev.end()) {
            g_util->log(3, -1, "CBgtRt::getTermMsk(): voice handle not found. handle is %d", iVoiceHandle);
            return resultFUNC_BAD_PARAMETER;
        }

        CVoiceDev *pVD = reinterpret_cast<CVoiceDev*>(itL2P->second);

        (*lMask) = pVD->getTermMsk();

        return resultSUCCESS;
    }

    int CBgtRt::resultMsg(int iGcValue, char** pszGcMsg, int iCcValue, char** pszCcMsg)
    {
        switch (iGcValue) {
        case GC_NORMAL_CLEARING:
            (*pszGcMsg) = const_cast<char*>(astrGcResultMsgs[1].c_str());
            break;
        default:
            (*pszGcMsg) = const_cast<char*>(astrGcResultMsgs[0].c_str());
            break;
        }
        (*pszCcMsg) = const_cast<char*>(astrCcResultMsgs[0].c_str());
        return resultSUCCESS;
    }

    int CBgtRt::resultMsg(int iCcLibId, long lResultCode, char **pszMsg)
    {
        // messages are dependent on type of CC lib used; cclibid should
        // be to checked to get correct message
        switch (lResultCode) {
        case GC_NORMAL_CLEARING:
            (*pszMsg) = const_cast<char*>(astrGcResultMsgs[1].c_str());
            break;
        default:
            (*pszMsg) = const_cast<char*>(astrGcResultMsgs[0].c_str());
            break;
        }
        return resultSUCCESS;
    }

    int CBgtRt::ccLibIDToName(long lCcLibId, char** pszCcLibName)
    {
        (*pszCcLibName) = const_cast<char*>(astrCcLibNames[0].c_str());
        return resultSUCCESS;
    }

    void CBgtRt::setGcResult(int iGcResult) 
    { 
        m_iGcResult = iGcResult; 
    }

    void CBgtRt::setCcLibId(int iCcLibId)
    { 
        m_iCcLibId = iCcLibId; 
    }

    void CBgtRt::setCcLibResult(long lCcLibResult)
    { 
        m_lCcLibResult = lCcLibResult; 
    }
}

---