client.cpp

Go to the documentation of this file.

#include "client.hpp"
 
Client::Client() : _tmpMsg(), _fd(-1) {}
 
Client::Client(const std::string& address, const size_t& port) : _tmpMsg(), _fd(-1)
{
    connect(address, port);
}
 
void Client::_networkError(std::string&& errorMsg)
{
    disconnect();
    errorMsg += strerror(errno);
    errorMsg += " (errno: " + std::to_string(errno) + ")";
    throw std::runtime_error(errorMsg);
}
 
void Client::connect(const std::string& address, const size_t& port)
{
    disconnect();
 
    _fd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (_fd < 0)
        return _networkError("Cannot create socket");
 
    sockaddr_in sockaddr;
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port   = htons(port);
 
    if (inet_pton(AF_INET, address.c_str(), &sockaddr.sin_addr) <= 0)
    {
        hostent* host = gethostbyname(address.c_str());
        if (!host)
            return _networkError("Cannot resolve hostname: " + address);
 
        memcpy(&sockaddr.sin_addr, host->h_addr, host->h_length);
    }
 
    if (::connect(_fd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0)
        return _networkError("Cannot connect to socket: ");
}
 
void Client::disconnect()
{
    if (_fd > 0)
    {
        // shutdown(_fd, SHUT_RDWR);
        close(_fd);
    }
    _fd = -1;
}
 
void Client::defineAction(const Message::Type&                           messageType,
                          const std::function<void(const Message& msg)>& action)
{
    _triggers[messageType].push_back(action);
}
 
void Client::send(const Message& message)
{
    auto data = message.getSerializedData();
    ::send(_fd, data.data(), data.size(), 0);
}
 
bool Client::_isConnected() const
{
    if (_fd <= 0)
        return false;
 
    int       error = 0;
    socklen_t len   = sizeof(error);
 
    // Si la socket est fermée, getsockopt va échouer ou renvoyer une erreur
    return (getsockopt(_fd, SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0);
}
 
void Client::_receiveMessage()
{
 
    char buffRead[MAX_READ_BUFFER];
    int  bytes;
    while ((bytes = recv(_fd, buffRead, sizeof(buffRead), MSG_DONTWAIT)) > 0)
    {
        _tmpMsg.appendBytes(reinterpret_cast<unsigned char*>(buffRead), bytes);
    }
 
    if (bytes == 0)
    {
        // Connexion fermée par le serveur
        disconnect();
        return;
    }
 
    if (bytes == -1 && errno != EAGAIN && errno != EWOULDBLOCK)
    {
        // Déconnexions réseau (ne pas lever d'exception)
        if (errno == ENOTCONN ||   // Transport endpoint is not connected
            errno == ECONNRESET || // Connection reset by peer
            errno == EPIPE ||      // Broken pipe
            errno == EBADF)        // Bad file descriptor
        {
            disconnect();
            return;
        }
 
        _networkError("Cannot receive message: ");
    }
 
    while (_tmpMsg.isComplet())
    {
        Message::Type msgType;
        _tmpMsg >> msgType;
 
        Message newMsg(msgType);
 
        size_t dataSize;
        _tmpMsg >> dataSize;
 
        newMsg.appendBytes(_tmpMsg.getBuffer()->data().data(), dataSize);
 
        _tmpMsg.incr_cursor(dataSize);
 
        _msgs.push_back(newMsg);
    }
}
 
void Client::update()
{
    if (!_isConnected())
        return;
    while (_fd > 0)
    {
        FD_ZERO(&_readyRead);
        FD_SET(_fd, &_readyRead);
 
        timeval timeout = {0, 10000}; // Pour que le select soit non bloquant
 
        int ready = select(_fd + 1, &_readyRead, NULL, NULL, &timeout);
        if (ready <= 0 || !FD_ISSET(_fd, &_readyRead))
            break;
 
        _receiveMessage();
    }
 
    for (auto& msg : _msgs)
    {
        auto it = _triggers.find(msg.type());
        if (it == _triggers.end())
            continue;
 
        for (auto& funct : it->second)
            funct(msg);
    }
    _msgs.clear();
}