ptcall.cpp

来自「基于sipfoundy 公司开发的sipx协议API」· C++ 代码 · 共 1,686 行 · 第 1/4 页

        TaoString params(arg, TAOMESSAGE_DELIMITER);

        int cnt = params.getCnt();
        rc = (PtStatus)atoi(params[2]);

        if (cnt >= 2 && rc == PT_SUCCESS)
        {
                rSrcConnection = PtConnection(mpClient,
                                                                                params[0],
                                                                                mCallId.data());
                rDstConnection = PtConnection(mpClient,
                                                                                params[1],
                                                                                mCallId.data());
        }


        EVENT_TRACE("Exiting PtCall::consult:\n") ;
        return rc;
}

PtStatus PtCall::drop()
{
        EVENT_TRACE("Entering PtCall::drop:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::DROP,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        mCallId);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::DROP);
#endif
        mpEventMgr->release(pe);

    mState = INVALID;

        EVENT_TRACE("Exiting PtCall::drop:\n") ;
        return PT_SUCCESS;
}


// Sets the CPU codec limit for this call.
PtStatus PtCall::setCodecCPULimit(const int limit,
                                  const UtlBoolean bAutoRenegotiate)
{
        EVENT_TRACE("Entering PtCall::setCodecCPULimit:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();
   char buff[MAXIMUM_INTEGER_STRING_LENGTH];

   UtlString arg(mCallId) ;

   // Add Limit
   arg += TAOMESSAGE_DELIMITER ;
   sprintf(buff, "%d", limit) ;
   arg += buff ;

   // Add Auto Renegotiate
   arg += TAOMESSAGE_DELIMITER ;
   sprintf(buff, "%d", bAutoRenegotiate) ;
   arg += buff ;

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
         TaoMessage::SET_CODEC_CPU_LIMIT,
                        transactionId,
                        0,
                        (TaoObjHandle)pe,
                        3,
                        arg);

        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::SET_CODEC_CPU_LIMIT);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::setCodecCPULimit:\n") ;
        return PT_SUCCESS;
}


// Forces the renegotation of all connections for this call.
PtStatus PtCall::forceCodecRenegotiation()
{
        EVENT_TRACE("Entering PtCall::forceCodecRenegotiation:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

   OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
         TaoMessage::CODEC_RENEGOTIATE,
                        transactionId,
                        0,
                        (TaoObjHandle)pe,
                        1,
                        mCallId);

        mpClient->sendRequest(msg);


        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::CODEC_RENEGOTIATE);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::forceCodecRenegotiation:\n") ;
        return PT_SUCCESS;
}



/* ============================ ACCESSORS ================================= */

PtStatus PtCall::getCallListeners(PtCallListener* callListeners[],
                                                                   int size,
                                                                   int& rNumItems)
{
        EVENT_TRACE("Entering PtCall::getCallListeners:\n") ;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", size);
        UtlString arg(buff);

        arg += TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_CALL_LISTENERS,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CALL_LISTENERS);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::getCallListeners:\n") ;
        return PT_SUCCESS;
}

PtStatus PtCall::getCalledAddress(PtAddress& rAddress)
{
        EVENT_TRACE("Entering PtCall::getCalledAddress:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_CALLED_ADDRESS,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        mCallId);
        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        UtlString arg;
        pe->getStringData(arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CALLED_ADDRESS);
#endif
        mpEventMgr->release(pe);

        TaoString addresses(arg, TAOMESSAGE_DELIMITER);
        UtlString address;

        PtStatus rc = PT_SUCCESS;
        int cnt = atoi(addresses[0]);
        if (cnt > 2)
        {
                address = addresses[2];
                rAddress = PtAddress(mpClient, address.data());
        }
        else
        {
                rc = PT_NO_MORE_DATA;
        }

        EVENT_TRACE("Exiting PtCall::getCalledAddress:\n") ;
        return rc;
}

PtStatus PtCall::getCallingAddress(PtAddress& rAddress)
{
        EVENT_TRACE("Entering PtCall::getCallingAddress:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_CALLING_ADDRESS,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        mCallId);
        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        UtlString arg;
        pe->getStringData(arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CALLING_ADDRESS);
#endif
        mpEventMgr->release(pe);

        TaoString addresses(arg, TAOMESSAGE_DELIMITER);
        UtlString address;
        PtStatus rc = PT_SUCCESS;
        int cnt = atoi(addresses[0]);
        if (cnt > 2)
        {
                address = addresses[2];
                rAddress = PtAddress(mpClient, address.data());
        }
        else
        {
                rc = PT_NO_MORE_DATA;
        }
        EVENT_TRACE("Exiting PtCall::getCallingAddress:\n") ;
        return rc;
}

PtStatus PtCall::getCallingTerminal(PtTerminal& rTerminal)
{
        EVENT_TRACE("Entering PtCall::getCallingTerminal:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        UtlString       terminalName;
        OsSocket::getHostIp(&terminalName);

        terminalName += TAOMESSAGE_DELIMITER + mCallId;

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_CALLING_TERMINAL,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        terminalName);
        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        UtlString arg;
        pe->getStringData(arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CALLING_TERMINAL);
#endif
        mpEventMgr->release(pe);

        TaoString addresses(arg, TAOMESSAGE_DELIMITER);
        UtlString address;
        PtStatus rc = PT_SUCCESS;
        int cnt = addresses.getCnt();
        if (cnt > 2)
        {
                address = addresses[2];
                rTerminal = PtTerminal(address.data(), mpClient);
        }
        else
        {
                rc = PT_NO_MORE_DATA;
        }
        EVENT_TRACE("Entering PtCall::getCallingTerminal\n") ;
        return rc;
}

PtStatus PtCall::getConferenceController(PtTerminalConnection& rController)
{
        EVENT_TRACE("Entering PtCall::getConferenceController:\n") ;
        if (mpConfController)
                rController = PtTerminalConnection(*mpConfController);
        else
                return PT_NO_MORE_DATA;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_CONF_CONTROLLER,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        mCallId);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CONF_CONTROLLER);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::getConferenceController:\n") ;
        return PT_SUCCESS;
}