KjServerThread.cpp

Go to the documentation of this file.

#include "KjServerThread.h"

using namespace K3d;

KjServerThread::KjServerThread(char* _strConn, const char* _strCertFile,const char* _strKeyFile)
{
        cout << "KjServerThread::KjServerThread()"  << endl;
        m_pServer = new KjSslServer(_strConn, _strCertFile, _strKeyFile);
        m_pSignal = new KjSignal();
        m_bIsNewClientConn = false;
        m_pThread = NULL;
}

KjServerThread::~KjServerThread()
{
        if(m_pServer)
        {
                delete m_pServer;
                m_pServer = NULL;
        }
        if(m_pSignal)
        {
                delete m_pSignal;
                m_pSignal = NULL;
        }
}

void *KjServerThread::NewThread(void *_pArg)
{
        cout << "KjServerThread::NewThread()" << pthread_self() << endl;
        printf("Process %s: start\n", (char *)_pArg);
        // Check new client
        class KjClientConn *pClientConn = (class KjClientConn *) _pArg;
        cout << "pClientConn " << pClientConn << endl;
        pClientConn->NewClient();
        cout << "Thread" << pthread_self() << "Exiting" << endl;
        printf("Process %s: end\n", (char *)_pArg);
        return NULL;
}

void KjServerThread::CreateNewThread()
{
        int iRet;
        pthread_t *pThread = new pthread_t;
        // Create new client
        KjClientConn *pClientConn = new KjClientConn(m_pServer, pThread);
        m_tClientArray.push_back(pClientConn);
        
        // Create new thread and send client connection to the thread
        iRet = pthread_create(pThread, NULL, &NewThread, pClientConn);
        if (iRet != 0) fprintf(stderr, "create a failed %d\n", iRet);
}

int KjServerThread::GetNumClients()
{
        return (int)m_tClientArray.size();
}

KjClientConn *KjServerThread::GetClient(const int _iClientId)
{
        return m_tClientArray[_iClientId];
}

int KjServerThread::Start()
{
        int iRet;
        if(!m_pServer) 
        {
                cerr<< "Error:: int KjServer::Start() -- KjSslServer can`t allocated" << endl;
                return 0;
    }
        if(m_pServer->GetIsValid())
        {
                void * pRetval;
                // Create new thread 
                CreateNewThread();
                for(;;)
                {
                        // Check exit signals
                        if(m_pSignal->IsSigInt() || m_pSignal->IsSigQuit())
                        {
                                break;
                        }
                        for(int i=0; i<(int)m_tClientArray.size(); i++)
                        {
                                KjClientConn *pClient = m_tClientArray[i];
                                // Get if is client connected
                                if(pClient->GetIsConnected() == true)
                                {
                                        if(pClient->GetConn())
                                        {
                                                // Erase non valid client
                                                if(pClient->GetConn()->GetIsValid() == false)
                                                {
                                                        // Get client thread index
                                                        pthread_t iThreadId = pClient->GetThreadId();
                                                        cout << "Detach thread id " << iThreadId << endl;
                                                        printf("Wake up all waiters...\n");
                                                        pthread_t *pThread = pClient->GetThread();
                                                        iRet = pthread_join(*pThread, &pRetval);
                                                        if (pRetval != 0) fprintf(stderr, "join a failed %d\n", iRet);
                                                        cout << "Delete thread " << pThread << endl;
                                                        if(pThread)
                                                        {
                                                                cout << "Delete thread " << pThread << endl;
                                                                delete pThread;
                                                                pThread = NULL;
                                                        }
                                                        cout << "Thread is canceled " << endl;
                                                        // Delete client
                                                        if(pClient)
                                                        {
                                                                cout << "Delete client " << pClient << endl;
                                                                delete pClient;
                                                                pClient = NULL;
                                                        }
                                                        cout << "Erase client " << i << endl;
                                                        m_tClientArray.erase(m_tClientArray.begin()+i);
                                                }
                                                else
                                                {
                                                        // Check if client unlocked new thread
                                                        if (pClient->GetIsLockNewThread() == false)
                                                        {
                                                                pClient->GetIsLockNewThread() = true;
                                                                // Create new thread 
                                                                CreateNewThread();
                                                        }
                                                }
                                        }
                                        else
                                        {
                                                cout << "Client " << i << " is disconnected" << endl;
                                        }       
                                }
                        }
                }
        }
        else
        {
                cerr<< "Error:: int KjServer::Start() --Invalid SSL connection !!! " << endl;
        }
        cout << "int KjServer::Start() -- Server exit" << endl;
        return 0;
}

---