ptprovider.cpp

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

//
// Copyright (C) 2004, 2005 Pingtel Corp.
// 
//
// $$
////////////////////////////////////////////////////////////////////////
//////


// SYSTEM INCLUDES
#include <assert.h>
#include <string.h>

#ifdef __pingtel_on_posix__
#include <stdlib.h>
#endif

// APPLICATION INCLUDES
#include "ptapi/PtProvider.h"
#include "ptapi/PtProvider.h"
#include "ptapi/PtTerminal.h"
#include "ptapi/PtAddress.h"
#include "ptapi/PtCall.h"
#include "tao/TaoClientTask.h"
#include "tao/TaoServerTask.h"
#include "tao/TaoEvent.h"
#include "ptapi/PtProviderListener.h"
#include "tao/TaoString.h"
#include <cp/CpGatewayManager.h>


// EXTERNAL FUNCTIONS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
#define USE_MESSAGE_QUEUE 1

// STATIC VARIABLE INITIALIZATIONS
OsBSem               PtProvider::semInit(OsBSem::Q_PRIORITY, OsBSem::FULL) ;
PtProvider                      *PtProvider::spInstance = 0L;       // pointer to the single instance of
OsBSem                          PtProvider::sLock(OsBSem::Q_PRIORITY, OsBSem::FULL);
TaoClientTask           *PtProvider::mpClient = 0;

TaoReference            *PtProvider::mpTransactionCnt = 0;

TaoObjectMap            *PtProvider::mpCalls   = 0;
TaoReference            *PtProvider::mpCallCnt = 0;

TaoObjectMap            *PtProvider::mpAddresses  = 0;
TaoReference            *PtProvider::mpAddressCnt = 0;

UtlBoolean                       PtProvider::mbInvalidIP = FALSE;

unsigned int            PtProvider::mRef = 0;

int FORCE_REFERENCE_PtProvider = 0 ;


/* //////////////////////////// PUBLIC //////////////////////////////////// */

/* ============================ CREATORS ================================== */
// Obtaining access to a Provider (Pingtel Server)
PtStatus PtProvider::
getProvider(const char* login, const char* password,
                        const char* server, const char* options,
                        CpCallManager* pCallMgr,
                        PtProvider*& rpProvider)
{
        // If the task object already exists, and the corresponding low-level task
        // has been started, then use it
        if (spInstance != NULL)
        {
                rpProvider = spInstance;
                return PT_SUCCESS;
        }

        // If the task does not yet exist or hasn't been started, then acquire
        // the lock to ensure that only one instance of the task is started
        sLock.acquire();
        if (spInstance == NULL)
       spInstance = new PtProvider(login, password, server, options, pCallMgr);

        sLock.release();

        rpProvider = spInstance;
        return PT_SUCCESS;
}

PtProvider::PtProvider(const char* login, const char* password,
                        const char* server, const char* options, CpCallManager* pCallMgr)
{
        mpEventMgr = OsProtectEventMgr::getEventMgr();
        if (PT_SUCCESS == createProvider(login, password, server,  options, pCallMgr))
                mState = IN_SERVICE;
        else
                mState = OUT_OF_SERVICE;

}

PtStatus PtProvider::createProvider(const char* login, const char* password,
                        const char* server, const char* options,
         CpCallManager* pCallMgr)
{
        size_t   pos;
        UtlString svr = server;
        UtlString host;
        int port;

        pos = svr.index(":", (size_t)0);
        if (pos != UTL_NOT_FOUND)
        {
                host = svr(0, pos);
                port = atoi(svr((pos + 1), (svr.length() - pos - 1)).data());
                if (host.isNull() || 0 == host.compareTo("0.0.0.0"))
                {
                        host = "127.0.0.1";
                        mbInvalidIP = TRUE;
                        osPrintf("WARNING - PtProvider::createProvider: using invalid host, replaced with %s\n", host.data());
                }

                if (!portIsValid(port))
                        port = DEF_TAO_LISTEN_PORT;
        }
        else
        {
                return PT_INVALID_ARGUMENT;
        }

        if (!mpClient)
        {
                TaoServerTask *pTaoServerTask = NULL;
                if (USE_MESSAGE_QUEUE && isLocal(host))
                {
            // Part of decoupling Call Manager from Phone library
            // is to make this argument required
            assert(pCallMgr != NULL);

                        pTaoServerTask = TaoServerTask::getTaoServerTask(pCallMgr);
                        mpClient = new TaoClientTask(port, host, pTaoServerTask);
                        if (mpClient && pTaoServerTask)
                        {
                                pTaoServerTask->setClientHandle((TaoObjHandle) mpClient);
                                TaoObjHandle eventServer = mpClient->getEventServer();
                                pTaoServerTask->setEventClient((TaoObjHandle) eventServer);
                        }
                }
                else
                {
                        osPrintf("Ptprovider::createProvider: NOT a local host %s\n", host.data());
                        mpClient = new TaoClientTask(port, host, 0);
                }
        }

        if (mpClient && !(mpClient->isStarted()))
        {
                mpClient->start();
        }

        initialize();

        // formulate the message to be sent to the server
        UtlString       argList = login + TAOMESSAGE_DELIMITER + password;
        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_PROVIDER,
                                                                        TaoMessage::GET_PROVIDER,
                                                                        0,
                                                                        0, //NULL
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        argList);
        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;
        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_PROVIDER);
#endif
        mpEventMgr->release(pe);

#ifdef _VXWORKS
        if (mbInvalidIP)
        {
        char *title = "Error" ;
                char *text = "The network settings of this xpressa are incorrect or there is no connection to your network. Please check the network connection and xpressa preferences." ;

        // Call processing is now decoupled from Pinger library
        // this will have to be removed, but for now this is
        // only an issue for the hardphone

        JXAPI_MessageBox(MBT_ERROR, title, text, 0) ;
                //int delay = 30 * sysClkRateGet();
                //taskDelay(delay);
                //JNI_ClearStatus();
        }
#endif

        return PT_SUCCESS;
}

void PtProvider::initialize()
{
        mTimeOut = OsTime(PT_CONST_EVENT_WAIT_TIMEOUT, 0);
    semInit.acquire() ;
        mRef++;

        if (!mpTransactionCnt)
                mpTransactionCnt    = new TaoReference();

        if (!mpCalls)
                mpCalls   = new TaoObjectMap();
        if (!mpCallCnt)
                mpCallCnt = new TaoReference();

        if (!mpAddresses)
                mpAddresses  = new TaoObjectMap();
        if (!mpAddressCnt)
                mpAddressCnt = new TaoReference();

   semInit.release() ;
}

// Default Constructor
PtProvider::PtProvider()
{
   initialize();
}

// Copy constructor
PtProvider::PtProvider(const PtProvider& rPtProvider)
{
        spInstance = rPtProvider.spInstance;      // pointer to the single instance of
        mpClient = rPtProvider.mpClient;
        if (mpClient && !(mpClient->isStarted()))
        {
                mpClient->start();
        }

        mLogin = rPtProvider.mLogin;
        mPass = rPtProvider.mPass;

        mState = rPtProvider.mState;
        initialize();
        mpEventMgr = OsProtectEventMgr::getEventMgr();
}

PtProvider::PtProvider(UtlString& rLogin, UtlString& rPass)
{
        mLogin = rLogin;
        mPass = rPass;

        mpClient = 0;

        mState = IN_SERVICE;

        mpEventMgr = OsProtectEventMgr::getEventMgr();
        initialize();
}

// Destructor
PtProvider::~PtProvider()
{
    semInit.acquire() ;
        if (--mRef < 1)
        {
                if (mpClient)
                {
                        mpClient->requestShutdown();
                        delete mpClient;
                        mpClient = NULL;
                }

                if (mpTransactionCnt)
                {
                        delete mpTransactionCnt;
                        mpTransactionCnt = 0;
                }

                if (mpCalls)
                {
                        delete mpCalls;
                        mpCalls = 0;
                }

                if (mpCallCnt)
                {
                        delete mpCallCnt;
                        mpCallCnt = 0;
                }

                if (mpAddresses)
                {
                        delete mpAddresses;
                        mpAddresses = 0;
                }

                if (mpAddressCnt)
                {
                        delete mpAddressCnt;
                        mpAddressCnt = 0;
                }

                if (spInstance)
                {
                        spInstance = 0;
                }
        }
    semInit.release() ;
}


UtlBoolean PtProvider::isLocal(const char * host)
{
        UtlString strServer;
        OsSocket::getHostIp(&strServer);

//      osPrintf("%s isLocal %s?\n", host, strServer.data());
        if (strServer.length() == 0 || 0 == strServer.compareTo("0.0.0.0"))
        {
                mbInvalidIP = TRUE;
                return TRUE;
        }

        if (strServer.compareTo(host, UtlString::ignoreCase) == 0)
                return TRUE;

        OsSocket::getHostName(&strServer);
        if (strServer.compareTo(host, UtlString::ignoreCase) == 0)
                return TRUE;

        return FALSE;
}

/* ============================ MANIPULATORS ============================== */

PtStatus PtProvider::addProviderListener(PtProviderListener& rListener)
{
        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];