---

SignalDev.cpp

Go to the documentation of this file.

/*
 * SignalDev.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/SignalDev.h>
#include <bogotel/VoiceDev.h>
#include <bogotel/MsgTransport.h>
#include <bogotel/BgtErrors.h>
#include <bogotel/util.h>
#include <bogotel/Timer.h>

namespace bogotel {

    // 0 is not a valid CRN, start with 1
    long CSignalDev::m_lNextCrn = 1;

    const std::string CSignalDev::stateNames[10] = {
        "RESET",
        "NULL",
        "IDLE",
        "DIALING",
        "ALERTING",
        "OFFERED",
        "ACCEPTED",
        "CONNECTED",
        "DISCONNECTED",
        "DROPPED"
    };

    const std::string CSignalDev::eventNames[10] = {
        "UNBLOCKED",
        "OFFERED",
        "ALERTING",
        "ANSWERED",
        "ACCEPT",
        "CONNECTED",
        "DROPCALL",
        "DISCONNECTED",
        "RESETLINEDEV",
        "Unknown"
    };

    CSignalDev::CSignalDev(CBgtRt *pBgtRt) :
    CDevBase(pBgtRt),
    m_pUsrAttr(NULL),
    m_pVoiceDev(NULL),
    m_lSCbusTimeslot(-1),
    m_lHandle(-1),
    m_state(NS_RESET),
    m_bWaitCall(FALSE),
    m_bBlocked(TRUE),
    m_iGcResult(0)
    {
    }

    int CSignalDev::init(std::string strNetDev, std::string strProt, void *usrattr, long lHandle, long lTimeslot)
    {
        int rc;
        if ((rc = CDevBase::init()) != resultSUCCESS) {
            return rc;
        }

        m_strNetDev = strNetDev;
        m_strProt = strProt;
        m_pUsrAttr = usrattr;
        m_lHandle = lHandle;
        m_lSCbusTimeslot = lTimeslot;

        m_state = NS_NULL;
        m_bBlocked = FALSE;

        // add UNBLOCKED event to queue
        sendEvent(GCEV_UNBLOCKED, 0);

        return resultSUCCESS;
    }

    int CSignalDev::listen(CVoiceDev *pVD)
    {
        if (m_pVoiceDev != NULL) {
            return resultPOINTER;
        }
        m_pVoiceDev = pVD;
        
        log(9, "CSignalDev::listen() completed.");

        return resultSUCCESS;
    }

    int CSignalDev::waitCall()
    {
        m_bWaitCall = TRUE;
    //  m_state = NS_WAITING;
        log(9, "CSignalDev::waitCall() completed.");
        return resultSUCCESS;
    }

    int CSignalDev::makeCall(CRN *pCrn, char *szNumber, int iTimeout, char *szAni)
    {
        char _func[] = "CSignalDev::makeCall";
        (*pCrn) = m_lNextCrn;
        m_lNextCrn++;

        int rc;
        if ((rc = m_pBgtRt->registerCrn(this, (*pCrn))) != resultSUCCESS) {
            return rc;
        }

        m_pMsg->clear();
        m_pMsg->m_class = MC_SIGNAL;
        m_pMsg->m_type = MT_MAKE_CALL;
        m_pMsg->m_id = m_lHandle;
        m_pMsg->m_crn = (*pCrn);
        m_pMsg->addParam(PT_ANI, szAni? szAni : m_strAni);
        m_pMsg->addParam(PT_DNIS, szNumber);

        m_state = NS_DIALING;

        // ignore timeout if 0
        if (iTimeout != 0) {
            // schedule timer for timeout period
    //      m_pTimer->add(iTimeout * 1000, this);
        }
    
        if ((rc = sendMsg(m_pMsg)) != resultSUCCESS) {
            log(3, "sendMsg() failed in CSignalDev::makeCall(). rc is %d", rc);
            return rc;
        }
        log(7, "Dialing. ANI=%s. DNIS=%s", m_strAni.c_str(), szNumber);
        log(9, "CSignalDev::makeCall() completed.");
        return rc;
    }

    int CSignalDev::acceptCall(CRN crn)
    {
        m_pMsg->clear();
        m_pMsg->m_class = MC_SIGNAL;
        m_pMsg->m_type = MT_ACCEPT_CALL;
        m_pMsg->m_id = m_lHandle;
        m_pMsg->m_crn = crn;

        m_state = NS_ACCEPTED;

        int rc;
        if ((rc = sendMsg(m_pMsg)) != resultSUCCESS) {
            log(3, "sendMsg() failed in CSignalDev::acceptCall(). rc is %d", rc);
            return rc;
        }
        if ((rc = sendEvent(GCEV_ACCEPT, crn)) != resultSUCCESS) {
            log(3, "CSignalDev::acceptCall() sendEvent() failed. rc is %d", rc);
        }

        log(9, "CSignalDev::acceptCall() completed.");
        return rc;
    }

    int CSignalDev::answerCall(CRN crn)
    {
        m_pMsg->clear();
        m_pMsg->m_class = MC_SIGNAL;
        m_pMsg->m_type = MT_ANSWER_CALL;
        m_pMsg->m_id = m_lHandle;
        m_pMsg->m_crn = crn;

        m_state = NS_CONNECTED;

        int rc;
        if ((rc = sendMsg(m_pMsg)) != resultSUCCESS) {
            log(3, "sendMsg() failed in CSignalDev::answerCall(). rc is %d", rc);
            return rc;
        }

        if ((rc = sendEvent(GCEV_ANSWERED, crn)) != resultSUCCESS) {
            log(3, "CSignalDev::answerCall() sendEvent() failed. rc is %d", rc);
        }

        log(9, "CSignalDev::answerCall() completed.");
        return rc;
    }

    int CSignalDev::dropCall(CRN crn, int iCause)
    {
        m_pMsg->clear();
        m_pMsg->m_class = MC_SIGNAL;
        m_pMsg->m_id = m_lHandle;
        m_pMsg->m_crn = crn;
        m_pMsg->m_type = MT_DROPCALL;

        switch (m_state) {
        case NS_DIALING:
        case NS_ALERTING:
        case NS_OFFERED:
        case NS_ACCEPTED:
        case NS_CONNECTED:
            m_state = NS_DROPPING;
            break;
        case NS_DISCONNECTED: {
            int rc;
            m_state = NS_IDLE;
            if ((rc = sendEvent(GCEV_DROPCALL, crn)) != resultSUCCESS) {
                log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
            }
            break;
        }
        case NS_RESET:
        case NS_NULL:
        case NS_IDLE:
        default:
            log(3, "dropCall() called when in invalid state. state is %d", m_state);
            return resultUNEXPECTED;
        }
        int rc;
        if ((rc = sendMsg(m_pMsg)) != resultSUCCESS) {
            log(3, "sendMsg() failed in CSignalDev::answerCall(). rc is %d", rc);
            return rc;
        }

        log(9, "CSignalDev::dropCall() completed.");
        return rc;
    }

    int CSignalDev::resetLineDev()
    {
        // increase the current event ID so that if there are any
        // delayed events, their return will be ignored
        m_lId++;

        m_state = NS_NULL;
        m_bBlocked = FALSE;

        sendEvent(GCEV_RESETLINEDEV, 0);
        return resultSUCCESS;
    }

    int CSignalDev::releaseCall(CRN crn, unsigned long ulMode)
    {
        int rc;

        switch (m_state) {
        case NS_IDLE:
            m_state = NS_NULL;

            break;
        default:
            log(3, "releaseCall() called when in invalid state. state is %s", getStateName(m_state));
            m_pBgtRt->setGcResult(1);
            m_pBgtRt->setCcLibId(1);
            m_pBgtRt->setCcLibResult(1);
            return resultUNEXPECTED;
        }

        if ((rc = m_pBgtRt->deregisterCrn(crn)) != resultSUCCESS) {
            return rc;
        }

        if (ulMode == EV_ASYNC) {
            if ((rc = sendEvent(GCEV_RESETLINEDEV, 0)) != resultSUCCESS) {
                log(3, "CSignalDev::releaseCall() sendEvent() failed. rc is %d", rc);
            }
        }

        log(7, "Circuit is disconnected.");

        log(9, "CSignalDev::releaseCall() completed.");
        return resultSUCCESS;
    }

    int CSignalDev::resultValue(METAEVENT *pMetaEvent, int *piGcResult, int *piCcLibId, long *plCcLibResult)
    {
        (*piGcResult)    = m_iGcResult;
        (*piCcLibId)     = 0;
        (*plCcLibResult) = 0;
        return resultSUCCESS;
    }

    int CSignalDev::getDnis(char *szDnis)
    {
        strcpy(szDnis, m_strDnis.c_str());
        log(9, "CSignalDev::getDnis() completed.");
        return resultSUCCESS;
    }

    int CSignalDev::getAni(char *szAni)
    {
        strcpy(szAni, m_strAni.c_str());
        log(9, "CSignalDev::getAni() completed.");
        return resultSUCCESS;
    }

    int CSignalDev::setAni(char *szAni)
    {
        m_strAni = szAni;
        log(9, "CSignalDev::setAni() completed.");
        return resultSUCCESS;
    }

    int CSignalDev::receiveMsg(CMsg *pMsg)
    {
        int rc = resultSUCCESS;
        CRN crn = pMsg->m_crn;

        char szType[30];
        pMsg->getMsgTypeString(szType, sizeof(szType));
        log(7, "CSignalDev::receiveMsg(): %s type", szType);

        switch(pMsg->m_type) {
        case MT_DROPCALL:
            switch (m_state) {
            case NS_DIALING:
            case NS_ALERTING:
            case NS_OFFERED:
            case NS_ACCEPTED:
            case NS_CONNECTED:
                m_state = NS_DISCONNECTED;
                m_iGcResult = GC_NORMAL_CLEARING;
                if ((rc = sendEvent(GCEV_DISCONNECTED, crn)) != resultSUCCESS) {
                    log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
                }
                break;
            case NS_DROPPING:
                m_state = NS_IDLE;
                if ((rc = sendEvent(GCEV_DROPCALL, crn)) != resultSUCCESS) {
                    log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
                }
                // give up timeslice to other thread
                ::Sleep(0);
                break;
            case NS_RESET:
            case NS_NULL:
            case NS_DISCONNECTED:
            default:
                rc = resultUNEXPECTED;
                goto cleanup;
            }
            break;

        case MT_MAKE_CALL:
            // check that we can accept the message
            if (! (m_state == NS_NULL && m_bWaitCall)) {
                rc = resultUNEXPECTED;
                goto cleanup;
            }
            m_state = NS_OFFERED;
            m_strAni = pMsg->getParam(PT_ANI);
            m_strDnis = pMsg->getParam(PT_DNIS);
            if ((rc = m_pBgtRt->registerCrn(this, crn)) != resultSUCCESS) {
                goto cleanup;
            }
            if ((rc = sendEvent(GCEV_OFFERED, crn)) != resultSUCCESS) {
                log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
            }
            break;
        case MT_ACCEPT_CALL:
            // check that we can accept the message
            if (m_state != NS_DIALING) {
                rc = resultUNEXPECTED;
                goto cleanup;
            }
            m_state = NS_ALERTING;
            if ((rc = sendEvent(GCEV_ALERTING, crn)) != resultSUCCESS) {
                log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
            }
            break;
        case MT_ANSWER_CALL:
            // check that we can accept the message
            if (m_state != NS_DIALING && m_state != NS_ALERTING) {
                rc = resultUNEXPECTED;
                goto cleanup;
            }
            // invalidate the timer so that it will be ignored when it expires
            m_lId++;

            m_state = NS_CONNECTED;
            if ((rc = sendEvent(GCEV_CONNECTED, crn)) != resultSUCCESS) {
                log(3, "CSignalDev::receiveMsg() sendEvent() failed. rc is %d", rc);
            }
            log(7, "Circuit connected");
            break;

        default:
            log(3, "CSignalDev::receiveMsg(). Unknown message: type is %s. "
                "state is %s, waitcall is %s", szType, getStateName(m_state),
                m_bWaitCall? "TRUE":"FALSE");
            break;
        }

    cleanup:
        switch (rc) {
        case resultSUCCESS:
            log(9, "CSignalDev::receiveMsg() completed.");
            break;
        case resultUNEXPECTED:
            log(3, "CSignalDev::receiveMsg(). Invalid state for message \"%s\". "
                "state is %s, waitcall is %s", szType, getStateName(m_state).c_str(),
                m_bWaitCall? "TRUE":"FALSE");
            break;
        }
        return rc;
    }

    int CSignalDev::putEvt(unsigned long event_type, long len, void *pData, long err)
    {
        return sendEvent(event_type, 0);
    }

    int CSignalDev::sendEvent(long lType, long lCrn)
    {
        CEvt *pEvt = new CEvt();

        pEvt->m_pUsrAttr = m_pUsrAttr;
        pEvt->m_lLen = sizeof(void*);
        pEvt->m_lType = lType;
        pEvt->m_lVoiceDevHandle = m_pVoiceDev? m_pVoiceDev->getHandle() : CVoiceDev::invalidHandle;
        pEvt->m_lSignalDevHandle = m_lHandle;
        pEvt->m_ulFlags = GCME_GC_EVENT;
        pEvt->m_lCrn = lCrn;
        pEvt->m_iSysType = CEvt::SysType::DEVICE;

        int rc;
        if ((rc = m_pBgtRt->addEvent(pEvt)) != resultSUCCESS) {
            log(3, "m_pBgtRt->addEvent() failed.");
            return rc;
        }
        log(7, "CSignalDev::sendEvent(): %s type", getEventName(lType).c_str());
        return rc;
    }

    int CSignalDev::sendMsg(CMsg *pMsg)
    {
        char szType[30];
        pMsg->getMsgTypeString(szType, sizeof(szType));
        log(7, "CSignalDev::sendMsg(): %s type", szType);
        return m_pTransport->sendMsg(pMsg);
    }

    void CSignalDev::log(int iLevel, char *szFmt, ...)
    {
        va_list vl;
        char szTemp[2000];

        va_start(vl, szFmt);
        _vsnprintf(szTemp, sizeof(szTemp), szFmt, vl);
        va_end(vl);

        g_util->log(iLevel, m_lHandle, szTemp);
    }

    void CSignalDev::logF(char *szFunc, int iLevel, char *szFmt, ...)
    {
        char szFmtWFunc[2000];
        _snprintf(szFmtWFunc, sizeof(szFmtWFunc), "Error in %s(): %s", szFunc, szFmt);

        va_list vl;
        char szTemp[2000];

        va_start(vl, szFmt);
        _vsnprintf(szTemp, sizeof(szTemp), szFmtWFunc, vl);
        va_end(vl);

        g_util->log(iLevel, m_lHandle, szTemp);
    }

    const std::string& CSignalDev::getStateName(int state) {
        return stateNames[state];
    }

    const std::string& CSignalDev::getEventName(long lType)
    {
        switch(lType) {
        case GCEV_UNBLOCKED:    return eventNames[0];
        case GCEV_OFFERED:      return eventNames[1];
        case GCEV_ALERTING:     return eventNames[2];
        case GCEV_ANSWERED:     return eventNames[3];
        case GCEV_ACCEPT:       return eventNames[4];
        case GCEV_CONNECTED:    return eventNames[5];
        case GCEV_DROPCALL:     return eventNames[6];
        case GCEV_DISCONNECTED: return eventNames[7];
        case GCEV_RESETLINEDEV: return eventNames[8];
        default:                return eventNames[9];
        }
    }

}

---