taocalladaptor.cpp

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

                return TAO_SUCCESS;
        }


        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callConsult(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 5)
                return TAO_FAILURE;

   UtlString argList = rMsg.getArgList();
        TaoString       args(argList, TAOMESSAGE_DELIMITER);
        UtlString consultAddressUrl;
        UtlString activeOriginalCallId;
        UtlString originalCallControllerAddress;
        UtlString originalCallControllerTerminalId;
        UtlString idleTargetCallId;

        UtlString targetCallControllerAddress;
        UtlString targetCallConsultAddress;

        originalCallControllerTerminalId = args[0];
        originalCallControllerAddress = args[1];
        activeOriginalCallId = args[2];
        idleTargetCallId = args[3];
        consultAddressUrl = args[4];

    int ret = mpCallMgrTask->consult(idleTargetCallId.data(),
                                                                        activeOriginalCallId.data(),
                                                                        originalCallControllerAddress.data(),
                                                                        originalCallControllerTerminalId.data(),
                                                                        consultAddressUrl.data(),
                                                                        targetCallControllerAddress,
                                                                        targetCallConsultAddress);

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        argList = targetCallControllerAddress + TAOMESSAGE_DELIMITER + targetCallConsultAddress;
        char buf[20];
        sprintf(buf, "%d", ret);

        argList += TAOMESSAGE_DELIMITER + buf;
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        rMsg.setArgCnt(3);
        rMsg.setArgList(argList);

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

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callDrop(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        UtlString callId = rMsg.getArgList();

        mpCallMgrTask->drop(callId);

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);

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

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::getDrop(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString callId;
        int call = rMsg.getTaoObjHandle();

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::DROP,
                                                                        rMsg.getMsgID(),
                                                                        call,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

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

        return TAO_FAILURE;
}


TaoStatus TaoCallAdaptor::callSetCodecCPULimit(TaoMessage& rMsg)
{
   int  argCnt = rMsg.getArgCnt();

        if (argCnt != 3)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString  argString = rMsg.getArgList();
   TaoString args(argString, TAOMESSAGE_DELIMITER);
        int call = rMsg.getTaoObjHandle();

   UtlString  callId = args[0] ;
   int       iLevel = atoi(args[1]) ;
   UtlBoolean bRenegotiate = atoi(args[2]) ;

   mpCallMgrTask->setCodecCPULimitCall(callId, iLevel, bRenegotiate) ;
        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::SET_CODEC_CPU_LIMIT,
                                                                        rMsg.getMsgID(),
                                                                        call,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

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

        return TAO_FAILURE;
}


TaoStatus TaoCallAdaptor::callCodecRenegotiate(TaoMessage& rMsg)
{
   int  argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString callId = rMsg.getArgList();
        int call = rMsg.getTaoObjHandle();

   mpCallMgrTask->renegotiateCodecsAllTerminalConnections(callId.data()) ;

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_CODEC_CPU_COST,
                                                                        rMsg.getMsgID(),
                                                                        call,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

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

        return TAO_FAILURE;
}





TaoStatus TaoCallAdaptor::callGetCodecCPUCost(TaoMessage& rMsg)
{
        int argCnt = rMsg.getArgCnt();
   int iCodecCPUCodec = 1 ;

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString callId = rMsg.getArgList();
        int call = rMsg.getTaoObjHandle();

   mpCallMgrTask->getCodecCPUCostCall(callId, iCodecCPUCodec) ;


   char buff[MAXIMUM_INTEGER_STRING_LENGTH];
        sprintf(buff, "%d", iCodecCPUCodec);
   UtlString arg(buff) ;

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_CODEC_CPU_COST,
                                                                        rMsg.getMsgID(),
                                                                        call,
                                                                        clientSocket,
                                                                        1,
                                                                        buff);

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

        return TAO_FAILURE;
}


TaoStatus TaoCallAdaptor::callGetCodecCPULimit(TaoMessage& rMsg)
{
        int argCnt = rMsg.getArgCnt();
   int iCodecCPULimit = 1 ;

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString callId = rMsg.getArgList();
        int call = rMsg.getTaoObjHandle();

   mpCallMgrTask->getCodecCPULimitCall(callId, iCodecCPULimit) ;


   char buff[MAXIMUM_INTEGER_STRING_LENGTH];
        sprintf(buff, "%d", iCodecCPULimit);
   UtlString arg(buff) ;

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_CODEC_CPU_LIMIT,
                                                                        rMsg.getMsgID(),
                                                                        call,
                                                                        clientSocket,
                                                                        1,
                                                                        buff);

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

        return TAO_FAILURE;
}


TaoStatus TaoCallAdaptor::callGetCalledAddress(TaoMessage& rMsg)
{
        // for now, return all addresses on this call

        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        UtlString callId = rMsg.getArgList();
        UtlString argList;

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

        if (numConnections)
        {
                numConnections = 2*numConnections + 1;  // make sure it's big enough
                UtlString *addresses;
                addresses = new UtlString[numConnections];

                if (addresses)
                {
                        int maxConnections = numConnections;
                        mpCallMgrTask->getCalledAddresses(callId.data(),
                                                                                        maxConnections,
                                                                                        numConnections,
                                                                                        addresses);

                        if (numConnections > maxConnections)
                                numConnections = maxConnections;

                        for (int i = 0; i < numConnections; i++)
                        {
                                callId += TAOMESSAGE_DELIMITER + addresses[i];
                                argCnt++;
                        }

                        delete[] addresses;
                }
        }

        argCnt++;
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        rMsg.setArgCnt(argCnt);
        char buf[20];
        sprintf(buf, "%d", argCnt);
        argList = buf + TAOMESSAGE_DELIMITER + callId;
        rMsg.setArgList(argList);

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

        return TAO_FAILURE;

}

TaoStatus TaoCallAdaptor::callGetCallingAddress(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        UtlString callId = rMsg.getArgList();
        UtlString argList;

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

        if (numConnections)
        {
                numConnections = 2*numConnections + 1;  // make sure it's big enough
                UtlString *addresses;
                addresses = new UtlString[numConnections];

                if (addresses)
                {
                        int maxConnections = numConnections;
                        mpCallMgrTask->getCallingAddresses(callId.data(),
                                                                                        maxConnections,
                                                                                        numConnections,
                                                                                        addresses);

                        if (numConnections > maxConnections)
                                numConnections = maxConnections;

                        for (int i = 0; i < numConnections; i++)
                        {
                                callId += TAOMESSAGE_DELIMITER + addresses[i];
                                argCnt++;
                        }

                        delete[] addresses;
                }
        }

        argCnt++;
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        rMsg.setArgCnt(argCnt);
        char buf[20];
        sprintf(buf, "%d", argCnt);
        argList = buf + TAOMESSAGE_DELIMITER + callId;
        rMsg.setArgList(argList);

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


        return TAO_FAILURE;

}

TaoStatus TaoCallAdaptor::callGetCallingTerminal(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

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

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

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

        if (terminalNames)
        {
                int maxConnections = numConnections;
                mpCallMgrTask->getTerminalConnections(callId.data(),
                                                                                        address.data(),
                                                                                        maxConnections,
                                                                                        numConnections,
                                                                                        terminalNames);

                if (numConnections > maxConnections)
                        numConnections = maxConnections;

                callId += TAOMESSAGE_DELIMITER + address;
                for (int i = 0; i< numConnections; i++)
                {
                        callId += TAOMESSAGE_DELIMITER + terminalNames[i];
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
                rMsg.setArgCnt(numConnections + 2);
                rMsg.setArgList(callId);

                delete[] terminalNames;

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

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callGetCallListeners(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();
        UtlString arg = rMsg.getArgList();

        TaoObjHandle rTerminal = 0x00000099;    // fake
        arg = "1" + TAOMESSAGE_DELIMITER + "101";

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_CALL_LISTENERS,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        2,
                                                                        arg);

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

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callGetConfController(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();
        UtlString arg = rMsg.getArgList();

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_CONF_CONTROLLER,
                                                                        rMsg.getMsgID(),