ptconnection.cpp

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

PtStatus PtConnection::getState(int& rState)
{
        EVENT_TRACE("Entering PtConnection::getState\n") ;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        UtlString arg(mCallId);

        arg += TAOMESSAGE_DELIMITER + mAddress;

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CONNECTION,
                                                                        TaoMessage::GET_STATE,
                                                                        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;
        }

        int rc;
        int argCnt = 0;
        arg.remove(0);
        pe->getEventData((int &)rc);
        pe->getIntData(argCnt);
        pe->getStringData(arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_STATE);
#endif
        mpEventMgr->release(pe);

        PtStatus ret = PT_SUCCESS;
        if (argCnt == 1)
        {
                mState = rState = atoi(arg.data());
        }
        else
        {
                mState = rState = UNKNOWN;
                ret = PT_NOT_FOUND;
        }
        EVENT_TRACE("Exiting PtConnection::getState\n") ;
        return ret;
}

PtStatus PtConnection::getToField(char* pName, int len)
{
        EVENT_TRACE("Entering PtConnection::getToField\n") ;
        PtStatus ret = PT_FAILED;
        if (pName == 0)
                return ret;

        UtlString arg = mCallId + TAOMESSAGE_DELIMITER + mAddress;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

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

        arg.remove(0);
        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->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_TO_FIELD);
#endif
        mpEventMgr->release(pe);

        TaoString argList(arg, TAOMESSAGE_DELIMITER);

        if (argList.getCnt() == 2)
        {
                ret = (PtStatus) atoi(argList[0]);
                arg = argList[1];
                int l = arg.length();
                if (l > len) l = len;
                strncpy(pName, arg.data(), l);
                pName[l] = 0;
        }

        EVENT_TRACE("Exiting PtConnection::getToField\n") ;
        return ret;
}

PtStatus PtConnection::getFromField(char* pName, int len)
{
        EVENT_TRACE("Entering PtConnection::getFromField\n") ;
        PtStatus ret = PT_FAILED;
        if (pName == 0)
                return ret;

        UtlString arg = mCallId + TAOMESSAGE_DELIMITER + mAddress;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

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

        arg.remove(0);
        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->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_FROM_FIELD);
#endif
        mpEventMgr->release(pe);

        TaoString argList(arg, TAOMESSAGE_DELIMITER);

        if (argList.getCnt() == 2)
        {
                ret = (PtStatus) atoi(argList[0]);
                arg = argList[1];
                int l = arg.length();
                if (l > len) l = len;
                strncpy(pName, arg.data(), l);
                pName[l] = 0;
        }

        EVENT_TRACE("Exiting PtConnection::getFromField\n") ;
        return ret;
}


PtStatus PtConnection::numTerminalConnections(int& count)
{
        EVENT_TRACE("Entering PtConnection::numTerminalConnections\n") ;
        UtlString arg = mCallId + TAOMESSAGE_DELIMITER + mAddress;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

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

        arg.remove(0);
        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->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::NUM_TERM_CONNECTIONS);
#endif
        mpEventMgr->release(pe);

        TaoString argList(arg, TAOMESSAGE_DELIMITER);

        if (argList.getCnt() > 2)
        {
                count = atoi(argList[2]);
        }
        else
        {
                count = 0;
        }

        EVENT_TRACE("Exiting PtConnection::numTerminalConnections\n") ;
        return PT_SUCCESS;
}

PtStatus PtConnection::park(char* destinationURL, PtConnection& rNewConnection)
{
        EVENT_TRACE("Entering PtConnection::park\n") ;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        UtlString arg = destinationURL + TAOMESSAGE_DELIMITER + mCallId;

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

        EVENT_TRACE("Exiting PtConnection::park\n") ;
        return PT_SUCCESS;
}

PtStatus PtConnection::redirect(char* destinationURL, PtConnection& rNewConnection)
{
        EVENT_TRACE("Entering PtConnection::redirect\n") ;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        UtlString arg = mAddress + TAOMESSAGE_DELIMITER + destinationURL + TAOMESSAGE_DELIMITER + mCallId;

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CONNECTION,
                                                                        TaoMessage::REDIRECT,
                                                                        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;
        }

        int rc;
        arg.remove(0);

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

        TaoString args = TaoString(arg, TAOMESSAGE_DELIMITER);
        UtlString callId = args[2];
        UtlString retCode = args[3];

        rNewConnection = PtConnection(mpClient, destinationURL, callId.data());
        EVENT_TRACE("Exiting PtConnection::redirect\n") ;

        rc = atoi(retCode.data());
        return (PtStatus) rc;
}

PtStatus PtConnection::reject()
{
        EVENT_TRACE("Entering PtConnection::reject\n") ;
        UtlString arg = mCallId + TAOMESSAGE_DELIMITER + mAddress;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CONNECTION,
                                                                        TaoMessage::REJECT,
                                                                        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::REJECT);
#endif
        mpEventMgr->release(pe);
        EVENT_TRACE("Exiting PtConnection::reject\n") ;

        return PT_SUCCESS;
}

/* ============================ INQUIRY =================================== */

/* //////////////////////////// PROTECTED ///////////////////////////////// */
// Protected constructor.
PtConnection::PtConnection(const char* address, const char* callId)
{
        if (address)
                mAddress = address;

        if (callId)
                mCallId = callId;

        mpClient = 0;
        mState = IDLE;

        initialize();

}

/* //////////////////////////// PRIVATE /////////////////////////////////// */

/* ============================ FUNCTIONS ================================= */