ptcall.cpp

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

PtStatus PtCall::getConnections(PtConnection connections[],
                                                                 int size,
                                                                 int& rNumItems)
{
        EVENT_TRACE("Entering PtCall::getConnections:\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_CONNECTIONS,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        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;
        }

        arg.remove(0);
        pe->getStringData(arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CONNECTIONS);
#endif
        mpEventMgr->release(pe);

        TaoString addresses(arg, TAOMESSAGE_DELIMITER);
        UtlString address;
        PtStatus rc = PT_SUCCESS;
        int cnt = addresses.getCnt();
        if (cnt > 2)
        {
                rNumItems = cnt - 2;
                rNumItems =  (rNumItems > size) ? size : rNumItems;

                for (int i = 0; i < rNumItems; i++)
                {
                        address = addresses[i + 2];
                        connections[i] = PtConnection(mpClient, address.data(), mCallId.data());
                }
        }
        else
        {
                rNumItems = 0;
                rc = PT_NO_MORE_DATA;
        }
        EVENT_TRACE("Exiting PtCall::getConnections\n") ;
        return rc;
}

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

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_LAST_REDIRECTED_ADDRESS,
                                                                        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_LAST_REDIRECTED_ADDRESS);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::getLastRedirectedAddress:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::getTransferController(PtTerminalConnection& rController)
{
        EVENT_TRACE("Entering PtCall::getTransferController:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_TRANSFER_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_TRANSFER_CONTROLLER);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::getTransferController:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::getProvider(PtProvider& rProvider)
{
        EVENT_TRACE("Entering PtCall::getProvider:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_PROVIDER,
                                                                        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_PROVIDER);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::getProvider:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::numCallListeners(int& rCount)
{
        EVENT_TRACE("Entering PtCall::numCallListeners:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::NUM_CALL_LISTENERS,
                                                                        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::NUM_CALL_LISTENERS);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::numCallListeners:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::numConnections(int& rCount)
{
        EVENT_TRACE("Entering PtCall::numConnections:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::NUM_CONNECTIONS,
                                                                        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::NUM_CONNECTIONS);
#endif
        mpEventMgr->release(pe);

        TaoString argList(arg, TAOMESSAGE_DELIMITER);
        rCount = atoi(argList[1]);
        EVENT_TRACE("Exiting PtCall::numConnections:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::removeCallListener(PtCallListener& rCallListener)
{
        EVENT_TRACE("Entering PtCall::removeCallListener:\n") ;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];
        sprintf(buff, "%d", (int)&rCallListener);

        UtlString name;
        UtlString arg;
        if (PT_SUCCESS == rCallListener.getLocation(&name)) // must have the terminal name
        {
                arg = name.data() + TAOMESSAGE_DELIMITER + buff;
        }
        else
                return PT_INVALID_ARGUMENT;

        mpClient->removeEventListener(rCallListener);

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::REMOVE_CALL_LISTENER,
                                                                        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::REMOVE_CALL_LISTENER);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::removeCallListener:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::setConferenceController(PtTerminalConnection* pController)
{
        EVENT_TRACE("Entering PtCall::setConferenceController:\n") ;
        mpConfController = pController;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", (int)pController);
        UtlString arg(buff);

        arg += TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::SET_CONF_CONTROLLER,
                                                                        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::SET_CONF_CONTROLLER);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::setConferenceController:\n") ;

        return PT_SUCCESS;
}

PtStatus PtCall::setTransferController(PtTerminalConnection* pController)
{
        EVENT_TRACE("Entering PtCall::setTransferController:\n") ;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", (int)pController);
        UtlString arg(buff);

        arg += TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::SET_TRANSFER_CONTROLLER,
                                                                        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::SET_TRANSFER_CONTROLLER);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtCall::setTransferController:\n") ;

        return PT_SUCCESS;
}

//Transfers all participants currently on this PtCall, with the
//exception of the transfer controller participant, to the address
//indicated by the destination URL.
PtStatus PtCall::transfer(const char* destinationURL,