taoconnectionadaptor.cpp

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

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


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

#include "tao/TaoConnectionAdaptor.h"
#include "tao/TaoTransportTask.h"
#include "tao/TaoString.h"
#include "cp/CpCallManager.h"
#include "net/SipSession.h"

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

TaoConnectionAdaptor::TaoConnectionAdaptor(TaoTransportTask*& rpSvrTransport,
                                                        CpCallManager *pCallMgr,
                                                        TaoMessage& rMsg,
                                                        const int maxRequestQMsgs)
        : TaoAdaptor("TaoConnAdaptor-%d", maxRequestQMsgs),
        mpCallMgrTask(pCallMgr)
{
        mpSvrTransport = rpSvrTransport;
        parseMessage(rMsg);

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

TaoConnectionAdaptor::TaoConnectionAdaptor(TaoTransportTask*& rpSvrTransport,
                                                        CpCallManager *pCallMgr,
                                                        const int maxRequestQMsgs)
        : TaoAdaptor("TaoConnAdaptor-%d", maxRequestQMsgs),
        mpCallMgrTask(pCallMgr)
{
        mpSvrTransport = rpSvrTransport;
        if (!isStarted())
        {
                start();
        }
}

TaoConnectionAdaptor::~TaoConnectionAdaptor()
{

}

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

        switch (((TaoMessage&)rMsg).getCmd())
        {
        case TaoMessage::ACCEPT:
                if (TAO_SUCCESS == connectionAccept((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::DISCONNECT:
                if (TAO_SUCCESS == connectionDisconnect((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_ADDRESS:
                if (TAO_SUCCESS == connectionGetAddress((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALL:
                if (TAO_SUCCESS == connectionGetCall((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_SESSION_INFO:
                if (TAO_SUCCESS == connectionGetSessionInfo((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_STATE:
                if (TAO_SUCCESS == connectionGetState((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_TERM_CONNECTIONS:
                if (TAO_SUCCESS == connectionGetTermConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_TERM_CONNECTIONS:
                if (TAO_SUCCESS == connectionNumTermConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::PARK:
                if (TAO_SUCCESS == connectionPark((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::REDIRECT:
                if (TAO_SUCCESS == connectionRedirect((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::REJECT:
                if (TAO_SUCCESS == connectionReject((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_FROM_FIELD:
                if (TAO_SUCCESS == connectionGetFromField((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_TO_FIELD:
                if (TAO_SUCCESS == connectionGetToField((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;
}

/* ----------------------------- CONNECTION ------------------------------- */
TaoStatus TaoConnectionAdaptor::connectionAccept(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString address = arg[1];


        mpCallMgrTask->acceptConnection(callId.data(), address.data());

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;
        return TAO_FAILURE;
}

TaoStatus TaoConnectionAdaptor::connectionDisconnect(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString remoteAddress = arg[1];

        mpCallMgrTask->dropConnection(callId.data(), remoteAddress.data());

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;
        return TAO_FAILURE;
}

TaoStatus TaoConnectionAdaptor::connectionGetAddress(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString address = arg[1];

        int numConnections = 0;
        mpCallMgrTask->getNumConnections(callId.data(), numConnections);

        UtlString *addresses;
        addresses = new UtlString[numConnections];

        UtlBoolean found = FALSE;
        if (addresses)
        {
                int maxConnections = numConnections;
                mpCallMgrTask->getConnections(callId.data(), maxConnections, numConnections, addresses);

                if (numConnections > maxConnections)
                        numConnections = maxConnections;

                for (int i = 0; i< numConnections; i++)
                {
                        if (!address.compareTo(addresses[i], UtlString::ignoreCase))
                        {
                                found = TRUE;
                                break;
                        }
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
                if (!found)
                {
                        rMsg.setArgCnt(0);      // not found
                        rMsg.setArgList("");
                }

                delete[] addresses;

                if (mpSvrTransport->postMessage(rMsg))
                        return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoConnectionAdaptor::connectionGetCall(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString address = arg[1];

        int numConnections = 0;
        mpCallMgrTask->getNumConnections(callId.data(), numConnections);

        UtlString *addresses;
        addresses = new UtlString[numConnections];

        UtlBoolean found = FALSE;
        if (addresses)
        {
                int maxConnections = numConnections;
                mpCallMgrTask->getConnections(callId.data(), maxConnections, numConnections, addresses);

                if (numConnections > maxConnections)
                        numConnections = maxConnections;

                for (int i = 0; i< numConnections; i++)
                {
                        if (!address.compareTo(addresses[i], UtlString::ignoreCase))
                        {
                                found = TRUE;
                                break;
                        }
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
                if (found)
                {
                        rMsg.setArgCnt(1);
                        rMsg.setArgList(callId);
                }
                else
                {
                        rMsg.setArgCnt(0);      // not found
                        rMsg.setArgList("");
                }

                delete[] addresses;

                if (mpSvrTransport->postMessage(rMsg))
                        return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoConnectionAdaptor::connectionGetFromField(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString address = arg[1];
        UtlString fromField;

        int ret = mpCallMgrTask->getFromField(callId.data(), address.data(), fromField);

        if (OS_SUCCESS == ret)
                ret = PT_SUCCESS;
        else