taoaddressadaptor.cpp

基于sipfoundy 公司开发的sipx协议API

//
// Copyright (C) 2004, 2005 Pingtel Corp.
// 
//
// $$
////////////////////////////////////////////////////////////////////////
//////


#ifdef TEST
#include "utl/UtlMemCheck.h"
#endif

#ifdef __pingtel_on_posix__
#include <stdlib.h>
#endif

#include <utl/UtlString.h>
#include "tao/TaoAddressAdaptor.h"
#include "tao/TaoTransportTask.h"
#include "tao/TaoString.h"
#include "ptapi/PtAddress.h"
#include "ptapi/PtAddressForwarding.h"
#include "cp/CpCallManager.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

TaoAddressAdaptor::TaoAddressAdaptor(TaoTransportTask*& rpSvrTransport,
                                           CpCallManager *pCallMgr,
                                           TaoMessage& rMsg,
                                           const UtlString& phoneNumber,
                                           const UtlString& name,
                                           const int maxRequestQMsgs)
        : TaoAdaptor("TaoAddressAdaptor-%d", maxRequestQMsgs)
{
        mpCallMgr = pCallMgr;
        mpSvrTransport = rpSvrTransport;
        parseMessage(rMsg);

        mName = new char[strlen(phoneNumber) + 1];
        strcpy(mName, phoneNumber);

        if (!isStarted())
        {
                start();
        }
}

TaoAddressAdaptor::~TaoAddressAdaptor()
{
        if (mName)
        {
                delete[] mName;
                mName = 0;
        }
}

UtlBoolean TaoAddressAdaptor::handleMessage(OsMsg& rMsg)
{
        UtlBoolean handled = FALSE;

        switch (((TaoMessage&)rMsg).getCmd())
        {
        case TaoMessage::ADD_ADDRESS_LISTENER:
                if (TAO_SUCCESS == addressAddAddressListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::ADD_CALL_LISTENER:
                if (TAO_SUCCESS == addressAddCallListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CANCEL_ALL_FORWARDING:
                if (TAO_SUCCESS == addressCancelAllForward((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CANCEL_FORWARDING:
                if (TAO_SUCCESS == addressCancelForward((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_ADDRESS_LISTENERS:
                if (TAO_SUCCESS == addressGetAddrListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALL_LISTENERS:
                if (TAO_SUCCESS == addressGetCallListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CONNECTIONS:
                if (TAO_SUCCESS == addressGetConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_DONOT_DISTURB:
                if (TAO_SUCCESS == addressGetDoNotDisturb((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_FORWARDING:
                if (TAO_SUCCESS == addressGetForwarding((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_MESSAGE_WAITING:
                if (TAO_SUCCESS == addressGetMsgWaiting((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_NAME:
                if (TAO_SUCCESS == addressGetName((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_OFFERED_TIMEOUT:
                if (TAO_SUCCESS == addressGetOfferedTimeout((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_PROVIDER:
                if (TAO_SUCCESS == addressGetProvider((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_TERMINALS:
                if (TAO_SUCCESS == addressGetTerminals((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_ADDRESS_LISTENERS:
                if (TAO_SUCCESS == addressNumAddrListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_CALL_LISTENERS:
                if (TAO_SUCCESS == addressNumCallListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_CONNECTIONS:
                if (TAO_SUCCESS == addressNumConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_FORWARDS:
                if (TAO_SUCCESS == addressNumForwards((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_TERMINALS:
                if (TAO_SUCCESS == addressNumTerminals((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::REMOVE_ADDRESS_LISTENER:
                if (TAO_SUCCESS == addressRemoveAddressListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::REMOVE_CALL_LISTENER:
                if (TAO_SUCCESS == addressRemoveCallListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_DONOT_DISTURB:
                if (TAO_SUCCESS == addressSetDoNotDisturb((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_FORWARDING:
                if (TAO_SUCCESS == addressSetForwarding((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_MESSAGE_WAITING:
                if (TAO_SUCCESS == addressSetMsgWaiting((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_OFFERED_TIMEOUT:
                if (TAO_SUCCESS == addressSetOfferedTimeout((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        default:
          break;
        }

        if (!handled)
        {
                TaoMessage*     pMsg = (TaoMessage*) &rMsg;

                pMsg->setArgCnt(1);
                pMsg->setArgList("-1");

                if (mpSvrTransport->postMessage(*pMsg))
                        handled = TRUE;
        }

        return handled;
}

/* ----------------------------- ADDRESS ---------------------------------- */
TaoStatus TaoAddressAdaptor::addressAddAddressListener(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle    clientSocket = rMsg.getSocket();
        TaoObjHandle    msgId = rMsg.getMsgID();
        TaoObjHandle    objHdl = rMsg.getTaoObjHandle();
//      UtlString               listener = rMsg.getArgList();

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_ADDRESS,
                                                                        TaoMessage::ADD_ADDRESS_LISTENER,
                                                                        msgId,
                                                                        objHdl,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoAddressAdaptor::addressAddCallListener(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        UtlString arg = "0";
        if (mpListenerMgr)
        {
                argCnt = 0;
                mpListenerMgr->addEventListener(rMsg);
        }
        else
        {
                argCnt = 1;
                arg = "-1";     // indicating dailure
        }


        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoObjHandle msgId = rMsg.getMsgID();
        TaoObjHandle objId = rMsg.getTaoObjHandle();

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_ADDRESS,
                                                                        TaoMessage::ADD_CALL_LISTENER,
                                                                        msgId,
                                                                        objId,
                                                                        clientSocket,
                                                                        argCnt,
                                                                        arg);

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoAddressAdaptor::addressCancelAllForward(TaoMessage& rMsg)
{
        mpCallMgr->cancelAddressForwarding(0, 0);

        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoObjHandle objId = rMsg.getTaoObjHandle();

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_ADDRESS,
                                                                        TaoMessage::CANCEL_ALL_FORWARDING,
                                                                        rMsg.getMsgID(),
                                                                        objId,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoAddressAdaptor::addressCancelForward(TaoMessage& rMsg)
{
        TaoString        argList(rMsg.getArgList(), TAOMESSAGE_DELIMITER);

        int size = atoi(argList[0]);

        PtAddressForwarding *pAddressForwards = new PtAddressForwarding[size];

        for (int i = 0, j = 1; i < size; i++)
        {
                int type = atoi(argList[j]);
                int filterType = atoi(argList[j + 1]);
                int noAnswerTimeout = atoi(argList[j + 4]);
                pAddressForwards[i] = PtAddressForwarding(argList[j + 2],
                                                                                                        type,
                                                                                                        filterType,
                                                                                                        argList[j + 3],
                                                                                                        noAnswerTimeout);
                j += 5;
        }
        mpCallMgr->cancelAddressForwarding(size, pAddressForwards);