taoconnectionadaptor.cpp

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

                ret = PT_NOT_FOUND;
        char buf[20];
        sprintf(buf, "%d", ret);
        callId = buf + TAOMESSAGE_DELIMITER + fromField;

        rMsg.setArgCnt(2);
        rMsg.setArgList(callId);
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

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

TaoStatus TaoConnectionAdaptor::connectionGetToField(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 toField;

        int ret = mpCallMgrTask->getToField(callId.data(), address.data(), toField);

        if (OS_SUCCESS == ret)
                ret = PT_SUCCESS;
        else
                ret = PT_NOT_FOUND;
        char buf[20];
        sprintf(buf, "%d", ret);
        callId = buf + TAOMESSAGE_DELIMITER + toField;

        rMsg.setArgCnt(2);
        rMsg.setArgList(callId);
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

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

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

        if (argCnt != 2)
                return TAO_FAILURE;

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

        if (OS_SUCCESS == mpCallMgrTask->getSession(callId.data(),
                                                                  address.data(),
                                  session))
        {
                char buff[MAXIMUM_INTEGER_STRING_LENGTH];
                Url url;
                int     cseq;

                session.getToUrl(url);
                sessionInfo = url.toString() + TAOMESSAGE_DELIMITER;

                session.getFromUrl(url);
                sessionInfo += url.toString() + TAOMESSAGE_DELIMITER;

                session.getLocalContact(url);
                sessionInfo += url.toString() + TAOMESSAGE_DELIMITER;

                cseq = session.getNextFromCseq();
                sprintf(buff, "%d", cseq);
                sessionInfo += buff + TAOMESSAGE_DELIMITER;

                cseq = session.getLastFromCseq();
                sprintf(buff, "%d", cseq);
                sessionInfo += buff + TAOMESSAGE_DELIMITER;

                cseq = session.getLastToCseq();
                sprintf(buff, "%d", cseq);
                sessionInfo += buff + TAOMESSAGE_DELIMITER;

                cseq = session.getSessionState();
                sprintf(buff, "%d", cseq);
                sessionInfo += buff;

                argCnt = 6;
        }
        else    // timed out
        {
                argCnt = 0;
        }


        rMsg.setArgCnt(argCnt);
        rMsg.setArgList(sessionInfo);
        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

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

        int state;
        if (mpCallMgrTask->getConnectionState(callId.data(), remoteAddress.data(), state))
        {
                char buff[MAXIMUM_INTEGER_STRING_LENGTH];

                sprintf(buff, "%d", state);
                argCnt = 1;
                argList = buff;
        }
        else
        {
                argCnt = 0;
        }

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CONNECTION,
                                                                        TaoMessage::GET_STATE,
                                                                        rMsg.getMsgID(),
                                                                        mState,
                                                                        clientSocket,
                                                                        argCnt,
                                                                        argList);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

        UtlString argList = rMsg.getArgList();
        TaoString arg(argList, TAOMESSAGE_DELIMITER);
        UtlString callId = arg[0];
        UtlString address = 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;

                for (int i = 0; i < numConnections; i++)
                {
                        argList += TAOMESSAGE_DELIMITER + terminalNames[i];
                        int isLocal = mpCallMgrTask->isTerminalConnectionLocal(callId.data(),
                                                                                        address.data(),
                                                                                        terminalNames[i].data());
                        char buff[128];
                        sprintf(buff, "%d", isLocal);
                        argList += TAOMESSAGE_DELIMITER + buff; // isLocal
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
                rMsg.setArgCnt(2 * numConnections + 2);
                rMsg.setArgList(argList);

                delete[] terminalNames;

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

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

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

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", numConnections);
        argList += TAOMESSAGE_DELIMITER + buff;

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
        rMsg.setArgCnt(3);
        rMsg.setArgList(argList);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CONNECTION,
                                                                        TaoMessage::PARK,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "9999");

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

        return TAO_FAILURE;
}

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

        if (argCnt != 3)
                return TAO_FAILURE;

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

        int ret = mpCallMgrTask->redirectConnection(callId.data(), address.data(), forwardAddress.data());

        char buf[20];
        sprintf(buf, "%d", ret);

        UtlString args = address + TAOMESSAGE_DELIMITER
                                        + forwardAddress + TAOMESSAGE_DELIMITER
                                        + callId + TAOMESSAGE_DELIMITER
                                        + buf;

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
        rMsg.setArgCnt(4);
        rMsg.setArgList(args);

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

TaoStatus TaoConnectionAdaptor::connectionReject(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->rejectConnection(callId.data(), address.data());

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);

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