Tcp cliente não lançar erro durante a conexão com localhost, se o servidor não está pronto

Question 1

Eu tentei incorporar todas as funcionalidades de rede para o meu programa, dentro de um "SimpleClient" de classe, que expõe esta interface dentro .a uhe de arquivo:

class SimpleClient{
    //private
        boost::shared_ptr<boost::asio::ip::tcp::socket> signal_socket; 
    protected: 
        boost::asio::io_context my_context;
        ClientState state; //0: Ready to be used, not connected,  -1: error, 1: Connected/active, 
    public: 
       SimpleClient();
       virtual bool connect(const char* ip_address);
       virtual void disconnect();
       virtual bool sendMessage(const char* msg, int length);
       virtual int getResponse( char* msg, int length, int timeout);
       virtual int getSignalData( char* msg, int length);
       virtual ClientState getState();
};

Durante o teste o método connect, notei que, mesmo se o servidor não estava esperando em localhost na porta 8887, conectar-se não jogar um erro. Como posso verificar que o socket está ligado para o real?

Aqui os métodos que eu implementado e um pequeno exemplo que reproduz o meu comportamento, usando o boost.teste:

SimpleClient::SimpleClient() : my_context() {
    signal_socket.reset();
    state = ClientState::CL_UNCON;
}

bool SimpleClient::connect(const char* ip_address) {
    boost::system::error_code ec;
    if (signal_socket != NULL && signal_socket->is_open() )
        return true;
    try {
        boost::asio::ip::tcp::endpoint signal_endpoint(boost::asio::ip::make_address(ip_address), 8887);
        signal_socket.reset(new boost::asio::ip::tcp::socket(my_context));
        signal_socket->connect(signal_endpoint, ec);
        if(ec) {
            std::cout<<ec.message()<<" "<<ec.value()<<std::endl;
            return false;
        }
    } catch(const boost::system::system_error& ex) {
        std::cout<<ex.code()<<std::endl;
        return false;
    }
    std::cout<<signal_socket<<std::endl;
    state = ClientState::CL_READY;
    return true;
}

Aqui está o programa de teste:

#define BOOST_AUTO_TEST_MAIN 
#define BOOST_TEST_DYN_LINK

#include "SimpleClient.hpp"

#include <boost/test/unit_test.hpp>

#include <string.h>

#define TARGET_IP "127.0.0.1"
#define BAD_IP "128.0.0.1"


BOOST_AUTO_TEST_CASE(connection_test)  {
    bool ret;
    std::cout<<"Connect to WRONG address"<<std::endl;
    SimpleClient* ut = new SimpleClient();
    BOOST_CHECK_EQUAL(ut->getState(), ClientState::CL_UNCON);
    ret = ut->connect(BAD_IP);
    BOOST_CHECK(!ret);
    std::cout<<"Connect to RIGHT address"<<std::endl;
    ret = ut->connect(TARGET_IP);
    BOOST_CHECK(ret);
    ut->disconnect();
    try{
        delete ut;
    }
    catch(const std::exception& ex) {
        std::cout<<ex.what()<<std::endl;
    }
    catch(...) {
    }
}

Question 2

O problema era dentro do meu método de conectar-se, obviamente. A primeira chamada a se conectar dentro do meu teste falhado, mas ele não fechar o socket, para a segunda chamada automaticamente retornado verdadeiro, sem a realização de qualquer operação.

TLDR: em caso de falha, conecte-se não fechar o socket, e qualquer chamada para is_open() irá retornar "true", chamada manualmente método close() no soquete em caso de erro.

bool SimpleClient::connect(const char* ip_address) {
    boost::system::error_code ec;
    if (signal_socket != NULL && signal_socket->is_open() )
        return true;
    try {
        boost::asio::ip::tcp::endpoint signal_endpoint(boost::asio::ip::make_address(ip_address), 8887);
        signal_socket.reset(new boost::asio::ip::tcp::socket(my_context));
        signal_socket->connect(signal_endpoint, ec);
        if(ec) {
            std::cout<<ec.message()<<" "<<ec.value()<<std::endl;
            signal_socket->close();
            signal_socket.reset();
            return false;
        }
    } catch(const boost::system::system_error& ex) {
        std::cout<<ex.code()<<std::endl;
        signal_socket->close();
        signal_socket.reset();
        return false;
    }
    std::cout<<signal_socket<<std::endl;
    state = ClientState::CL_READY;
    return true;
}

Gionata Benelli · Answer 1 · 2021-11-22T14:52:56

O problema era dentro do meu método de conectar-se, obviamente. A primeira chamada a se conectar dentro do meu teste falhado, mas ele não fechar o socket, para a segunda chamada automaticamente retornado verdadeiro, sem a realização de qualquer operação.

TLDR: em caso de falha, conecte-se não fechar o socket, e qualquer chamada para is_open() irá retornar "true", chamada manualmente método close() no soquete em caso de erro.

bool SimpleClient::connect(const char* ip_address) {
    boost::system::error_code ec;
    if (signal_socket != NULL && signal_socket->is_open() )
        return true;
    try {
        boost::asio::ip::tcp::endpoint signal_endpoint(boost::asio::ip::make_address(ip_address), 8887);
        signal_socket.reset(new boost::asio::ip::tcp::socket(my_context));
        signal_socket->connect(signal_endpoint, ec);
        if(ec) {
            std::cout<<ec.message()<<" "<<ec.value()<<std::endl;
            signal_socket->close();
            signal_socket.reset();
            return false;
        }
    } catch(const boost::system::system_error& ex) {
        std::cout<<ex.code()<<std::endl;
        signal_socket->close();
        signal_socket.reset();
        return false;
    }
    std::cout<<signal_socket<<std::endl;
    state = ClientState::CL_READY;
    return true;
}

Alternativamente, ajuste o controle de fluxo, de modo que o soquete não é utilizada após um erro. Esta é a abordagem mais natural. Muitas vezes, a verificação de "is_open" não é o que você está depois de qualquer maneira (e.g. ele não vai ser capaz de detectar quando a extremidade remota fechado uma conexão). +1 para a resposta a sua própria pergunta!

Tcp cliente não lançar erro durante a conexão com localhost, se o servidor não está pronto

Pergunta

Melhor resposta

Em outros idiomas

Esta página está em outros idiomas

Popular nesta categoria

Perguntas populares nesta categoria