src/net/client_common.cpp

Go to the documentation of this file.

#include <cstdio>
#include <malloc.h>
#include <alloca.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include "engine/mutex.h"
#include "net/packet.h"
#include "net/client_common.h"
#include "tools/log.h"
#include "tools/assert.h"


ClientCommon::ClientCommon(int _fd) : Mutex(RECURSIVE_MUTEX), fd(_fd), buffer(NULL), buffer_len(0), reconnect(false)
{
}

ClientCommon::~ClientCommon()
{
        Disconnect();
        free(buffer);
}

void ClientCommon::Disconnect()
{
        Lock();
        if(fd != -1)
        {
                shutdown(fd, SHUT_RDWR);
                close(fd);
        }
        fd = -1;
        free(buffer);
        buffer = NULL;
        buffer_len = 0;
        Unlock();
        OnDisconnect();
}

bool ClientCommon::Send(const char* buf, unsigned int len)
{
        Lock();
        while(true)
        {
                if(IsConnected())
                {
                        if(write(fd, buf, len) <= 0)
                        {
                                log(LogError, "Write to host %s failed : %s", GetAddress().c_str(), strerror(errno));
                                Disconnect();
                                continue;
                        }
                        else
                        {
                                Unlock();
                                return true;
                        }
                }
                if(!reconnect)
                {
                        Unlock();
                        return false;
                }
                sleep(1);
                Reconnect();
        }
        Unlock();
        return true;
}

bool ClientCommon::Send(Packet* p)
{
        Lock();
        char* pckt = NULL;
        unsigned int len = 0;
        p->DumpRaw(pckt, len);
        if(len <= 4)
                log(LogWarning, "Sending an empty packet to host %s", GetAddress().c_str());
        bool success = Send(pckt, len);
        free(pckt);
        Unlock();
        return success;
}

bool ClientCommon::Send(const std::string & str)
{
        if(str.size() == 0)
        {
                log(LogError, "Trying to send an empty string to host %s", GetAddress().c_str());
                return false;
        }
        return Send(str.c_str(), str.size());
}

bool ClientCommon::Receive(unsigned int len)
{
        Lock();
        buffer = (char*)realloc(buffer, buffer_len + len);
        memset(buffer + buffer_len, 0, len);
        while(true)
        {
                if(IsConnected())
                {
                        ssize_t read_len = read(fd, buffer + buffer_len, len);

                        if( read_len == -1)
                        {
                                log(LogError, "Read of len %i from host %s failed : %s", len, GetAddress().c_str(), strerror(errno));
                                Disconnect();
                                continue;
                        }
                        else
                        if( read_len == 0)
                        {
                                log(LogError, "Read from host %s failed : the host disconnected", GetAddress().c_str());
                                Disconnect();
                                continue;
                        }
                        buffer_len += read_len;
                        break;
                }
                if(!reconnect)
                {
                        Unlock();
                        return false;
                }
                sleep(1);
                Reconnect();
        }
        Unlock();
        return true;
}

std::string ClientCommon::ReceiveToEOL()
{
        Lock();
        bool eol_found = false;
        unsigned int eol_pos = 0;

        while(!eol_found)
        {
                if(!IsConnected() && !reconnect)
                {
                        Unlock();
                        return "";
                }

                for(; eol_pos < buffer_len; eol_pos++)
                        if(buffer[eol_pos] == '\n')
                        {
                                eol_found = true;
                                break;
                        }

                if(eol_found)
                        break;

                if(!Receive())
                        return "";
        }
                
        std::string str(buffer, eol_pos);

        while((buffer[eol_pos] == '\n' || buffer[eol_pos] == '\r') && eol_pos < buffer_len)
                eol_pos++;

        if(eol_pos == buffer_len)
        {
                free(buffer);
                buffer = NULL;
                buffer_len = 0;
        }
        else
        {
                char* tmp = (char*)malloc(buffer_len - eol_pos);
                memcpy(tmp, buffer + eol_pos, buffer_len - eol_pos);
                free(buffer);
                buffer = tmp;
                buffer_len -= eol_pos;
        }

        Unlock();
        return str;
}

Packet* ClientCommon::ReceivePacket()
{
        Lock();
        // Determine if we have enough data in the buffer to make a packet:
        unsigned int packet_size = 0;
        while(IsConnected() && (!packet_size || packet_size > buffer_len))
        {
                if(buffer_len > 4)
                        packet_size = ntohl(*(unsigned int*)buffer);
                if(buffer_len <= 4 || packet_size > buffer_len)
                        Receive();
        }

        if(!IsConnected() || !buffer)
        {
                Unlock();
                return NULL;
        }

        char* tmp = (char*)alloca(packet_size);
        memcpy(tmp, buffer, packet_size);

        Packet* p = new Packet(tmp);

        if(buffer_len == packet_size)
        {
                free(buffer);
                buffer = NULL;
                buffer_len = 0;
        }
        else
        {
                char* tmp_buf = (char*)malloc(buffer_len - packet_size);
                memcpy(tmp_buf, buffer + packet_size, buffer_len - packet_size);
                buffer_len -= packet_size;
                free(buffer);
                buffer = tmp_buf;
        }
        Unlock();
        return p;
}

int ClientCommon::BytesReceived()
{
        Lock();
        struct pollfd poll_str = { fd, POLLIN, 0};

        if(poll(&poll_str, 1, 1) == -1)
        {
                Disconnect();
                Unlock();
                return -1;
        }

        if(poll_str.revents & POLLERR
        || poll_str.revents & POLLHUP
        || poll_str.revents & POLLRDHUP
        || poll_str.revents & POLLNVAL)
        {
                Disconnect();
                Unlock();
                return -1;
        }

        if(!(poll_str.revents & POLLIN))
        {
                Unlock();
                return 0;
        }

        int received = 0;
        if( ioctl( fd, FIONREAD, &received) == -1 )
        {
                Disconnect();
                Unlock();
                return -1;
        }
        Unlock();
        return received;
}

const std::string ClientCommon::GetIp()
{
        std::string ip;
        Lock();
        ip = client_host;
        Unlock();
        return ip;
}

int ClientCommon::GetPort()
{
        int port;
        Lock();
        port = client_port;
        Unlock();
        return port;
}

---