KjClientConn.cpp

Go to the documentation of this file.

#include "KjClientConn.h"


KjClientConn::KjClientConn(KjSslServer *_pServer, pthread_t *_pThread)
{
        m_pServer = _pServer;
        m_pSslConn = NULL;
        m_pThread = _pThread;
        m_bIsConnected = false;
        m_bIsLockNewThread = true;
        m_strReadMsg = "";
        m_strWriteMsg = "";
        m_bCanRead = false;
}

KjClientConn::~KjClientConn()
{
}

void KjClientConn::DeleteEndMsg(string &_strMsg)
{
        size_t iFound = _strMsg.find(KJ_END_MSG);
        if (iFound!=string::npos)
        {
                string strEndMsg = KJ_END_MSG;
                _strMsg.erase(iFound , strEndMsg.size());
        }
}

void KjClientConn::ParseClientRequest(string &_strMsg)
{
        // Delete end message string if exists 
        DeleteEndMsg(_strMsg);
        // Set read message
        m_strReadMsg = _strMsg;
        m_bCanRead = true;
}

bool KjClientConn::ChatWithClient()
{
        if(m_pSslConn)
        {
                for(;;)
                {
                        string strClientMsg;
                        string strServerMsg;
                        strClientMsg.clear();
                        strServerMsg.clear();
                        // Read message from client
                        for(;;) //do
                        {
                                if(m_pSslConn)
                                {
                                        string strPacket;
                                        strPacket.clear();
                                        // Server read packet from client
                                        m_pSslConn->Read(strPacket);
                                        if(strPacket.empty())
                                        {
                                                cout << "Client is disconnected ... '" << endl;
                                                return false;
                                        }
                                        strClientMsg += strPacket;
                                        if(strPacket.find(KJ_END_MSG) != string::npos)
                                        {
                                                break;
                                        }
                                }
                                else
                                {
                                        cerr << "Error:: void KjServer::ChatWithClient(KjSslConnection * pCon) -- pCon doesn`t allocated !!!" << endl;
                                        return false;
                                }
                        }
                        
                        if(m_pSslConn)
                        {
                                strServerMsg = strClientMsg;
                                // Parse client request and get server message to client
                                ParseClientRequest(strServerMsg);
                        }
                        else
                        {
                                cerr << "Error:: void KjServer::ChatWithClient(KjSslConnection * pCon) -- pCon doesn`t allocated !!!" << endl;
                                return false;
                        }
                }
        }
        else
        {
                cerr << "Error:: void KjServer::ChatWithClient(KjSslConnection * pCon) -- pCon doesn`t allocated !!!" << endl;
                return false;
        }
        return true;
}

void KjClientConn::NewClient()
{
        cout << "KjServerThread::NewClient()" << endl;
        m_bIsConnected = false;
        m_bIsLockNewThread = true;
        m_pSslConn = m_pServer->NextClient();
        if(m_pSslConn)
        {
                // New client is connected
                m_bIsConnected = true;
                // Unlock new thread for new client connection
                m_bIsLockNewThread = false;
                m_iThreadId = pthread_self();
                cout << "Thread id is " << m_iThreadId << endl;
                cout << "m_pThread = " << m_pThread << endl;
                cout << "m_pSslConn = " << m_pSslConn << endl;
                // Chat with client
                if(ChatWithClient() == false)
                {
                        cout << "KjServerThread::NewClient -- Delete client ..." << endl;
                        m_pServer->DeleteClient(m_pSslConn);
                }
        }
        else
        {
                cerr << "Error:: void KjServer::NextClient() -- No connection!" << endl;
        }
}

string &KjClientConn::ReadMsg()
{
        // Clear write message
        m_strWriteMsg.clear();
        m_bCanRead = false;
        return m_strReadMsg;
}

void KjClientConn::WriteMsg(const string &_strMsg)
{
        m_strWriteMsg = _strMsg;
        if(m_pSslConn)
        {
                // Write message to client
                cout << "Server send message to client  '" << m_strWriteMsg << "'" << endl;
                m_pSslConn->Write(m_strWriteMsg.c_str());
                // Clear read message
                m_strReadMsg.clear();
        }
        else
        {
                cerr << "Error:: void KjClientConn::WriteMsg(const string &_strMsg) -- pCon doesn`t allocated !!!" << endl;
        }
}

---