[Boost Asio] Lecture du contenu de la socket

**Johnny29** · 28/11/2015, 20h40

Bonjour,

Je suis en train de r�aliser un petit tchat avec la librairie Boost asio, du type serveur/client.
Je me base sur le tuto http://gwenael-dunand.developpez.com...pp/boost/asio/ mais je rajoute une interface graphique avec Qt, et une gestion utilisateur avec base de donn�es.

Le client se connecte bien au serveur, je re�ois le "bienvenue sur le serveur".
Mais lorsque j'essaye d'envoyer un message du client vers le serveur ( pour envoyer le login) le client plante.
J'ai repris les fonction d'�criture du serveur et je l'ai transpos� au client et vise versa pour les fonction de lecture.

Es ce que c'est le fait que la socket contient d�j� quelque chose ? je dois effacer ce contenu ? ou je dois cr�� une autre socket entre le client et le serveur pour envoyer un message ?
Ce n'est pas les messages que je veux envoyer mais juste le login au serveur � la connexion du client.

Je suis un peu perdu :s

**Iradrille** · 30/11/2015, 09h32

Hello,

On peut voir ton code ? �� sera plus simple que d'essayer de deviner.

**Johnny29** · 01/12/2015, 13h23

oui pardon d�sol� sa sera plus simple

connexion.cpp,

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#include "connexion.h"
 
connexion::connexion(boost::asio::io_service& io_service) : m_socket(io_service)
{
    messagerie = new chat;
}
 
tcp::socket& connexion::socket()
{
    return m_socket;
}
 
void connexion::read()
{
     boost::asio::async_read(m_socket, boost::asio::buffer(m_network_buffer),
     boost::asio::transfer_at_least(20),
     boost::bind(&connexion::handle_read, shared_from_this(),
     boost::asio::placeholders::error,
     boost::asio::placeholders::bytes_transferred));
}
 
void connexion::handle_read(const boost::system::error_code& error, size_t number_bytes_read)
{
    if (!error)
    {
        std::cout.write(&m_network_buffer[0], number_bytes_read);
        read();
    }
    else
    {
        std::cout<<error.message();
    }
}
 
// c'est cette procédure que j'aimerais appeler dès que le client se connecte
void connexion::ecrire()
{
    std::string m_message;
    m_message = "Message venant du client";
    boost::asio::async_write(m_socket, boost::asio::buffer(m_message), boost::bind(&connexion::handle_write, shared_from_this(), boost::asio::placeholders::error) );
}
 
void connexion::handle_write(const boost::system::error_code& error)
    {
        if (!error)
        {
            // Autres actions éventuelles
        }
    }

client.h

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class tcp_client
{
    public:
            tcp_client(boost::asio::io_service& io_service, tcp::endpoint& endpoint);
 
    private:
        void connect(tcp::endpoint& endpoint)
        {
            connexion::pointer new_connection = connexion::create(m_io_service);
            tcp::socket& socket = new_connection->socket();
            socket.async_connect(endpoint, boost::bind(&tcp_client::handle_connect, this, new_connection, boost::asio::placeholders::error));
        }
 
        void handle_connect(connexion::pointer new_connection, const boost::system::error_code& error)
        {
            if(!error)
            {
                new_connection->read();
            }
        }
        boost::asio::io_service& m_io_service;
};

client.cpp

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
tcp_client::tcp_client(boost::asio::io_service& io_service, tcp::endpoint& endpoint) : m_io_service(io_service)
{
    connect(endpoint);
    std::cout<<"lancement connexion !"<<std::endl;
    //La je ferais appel à connexion::ecrire() mais sa ne marche pas
}

server.cpp

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
tcp_server::tcp_server(boost::asio::io_service& io_service, int port) : m_acceptor(io_service, tcp::endpoint(tcp::v4(), 4000))
{
    start_accept();
}
 
void tcp_server::start_accept()
{
	connexion::pointer connexion= connexion::create(m_acceptor.get_io_service());
 
	m_acceptor.async_accept(new_connection->socket(),
		boost::bind(&tcp_server::handle_accept, this, new_connection,
		boost::asio::placeholders::error));
}
 
void tcp_server::handle_accept(connexion::pointer new_connection, const boost::system::error_code& error)
{
	if (!error)
	{
		std::cout << "Reçu un client!" << std::endl;
		new_connection->start();
		start_accept();
	}
}

le serveur est sur une vm, je me connecte en local.
J'ai pas mis le code de la partie graphique, mais si tu veux je peux la rajouter

**Iradrille** · 01/12/2015, 13h37

Quelques probl�mes de const correctness, mais sinon le probl�me vient de la fonction connexion::ecrire() :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
void connexion::ecrire()
{
    std::string m_message;
    m_message = "Message venant du client";
    // m_message est une variable locale -> elle sera détruite avant l'envoi du message.
    // il faut une variable avec une durée de vie assez longue : typiquement un membre de ta classe
    // comme m_network_buffer; mais il faut 2 buffers par contre : 1 pour la lecture, 1 pour l'écriture.
    boost::asio::async_write(m_socket, boost::asio::buffer(m_message), boost::bind(&connexion::handle_write, shared_from_this(), boost::asio::placeholders::error) );
}

**Johnny29** · 02/12/2015, 10h28

je viens de cr�er un buffer dans chaque classe, toujours le m�me probl�me.
J'envoie un std::string, le r�cup�re dans un boost::array diff�rent dans chaque classe

je te remet le code avec les modifications

connexion.cpp cot� serveur

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
void tcp_connection::start()
{
    m_message = "Bienvenue sur le serveur!";
   boost::asio::async_write(m_socket, boost::asio::buffer(m_message),
			boost::bind(&tcp_connection::handle_write, shared_from_this(),
			boost::asio::placeholders::error)
			);
}
 
void tcp_connection::handle_write(const boost::system::error_code& error)
{
    if (!error)
    {
			// Autres actions éventuelles
    }
}
 
void tcp_connection::lire()
{
   boost::asio::async_read(m_socket, boost::asio::buffer(buffer),
    boost::asio::transfer_at_least(20),
    boost::bind(&tcp_connection::handle_read, shared_from_this(),
    boost::asio::placeholders::error,
    boost::asio::placeholders::bytes_transferred)
			);
}
 
void tcp_connection::handle_read(const boost::system::error_code& error, size_t number_bytes_read)
	{
		if (!error)
		{
			std::cout.write(&buffer[0], number_bytes_read);
			lire();
		}
		else {
			std::cout << error.message() ;
		}
	}

connexion.h cot� serveur

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
public:
	typedef boost::shared_ptr<tcp_connection> pointer;
	static pointer create(boost::asio::io_service& ios)
	{
	    return pointer(new tcp_connection(ios));
	}
	tcp::socket& socket()
	{
		return m_socket;
	}
	void start();
    void lire();


private:
    boost::array<char, 128> buffer;
    void handle_read(const boost::system::error_code& error, size_t number_bytes_read);
	tcp_connection(boost::asio::io_service& io_service) : m_socket(io_service)
	{

	}
	void handle_write(const boost::system::error_code& error);
	tcp::socket m_socket;
	std::string m_message;
};

serveur.cpp

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
tcp_server::tcp_server(boost::asio::io_service& io_service, int port) : m_acceptor(io_service, tcp::endpoint(tcp::v4(), 4000))
{
    start_accept();
}

void tcp_server::start_accept()
{
	tcp_connection::pointer new_connection = tcp_connection::create(m_acceptor.get_io_service());

	m_acceptor.async_accept(new_connection->socket(),
		boost::bind(&tcp_server::handle_accept, this, new_connection,
		boost::asio::placeholders::error));
}

void tcp_server::handle_accept(tcp_connection::pointer new_connection, const boost::system::error_code& error)
{
	if (!error)
	{
		std::cout << "Re�u un client!" << std::endl;
		new_connection->start();
		start_accept();
		new_connection->lire();
	}
}

connexion.h cot� client

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class connexion : public boost::enable_shared_from_this<connexion>
{
    public:
    connexion(boost::asio::io_service& io_service);
        typedef boost::shared_ptr<connexion>pointer;
        static pointer create(boost::asio::io_service &ios)
        {
            return pointer(new connexion(ios));
        }
        tcp::socket& socket();
        void read();
        boost::array<char, 128> m_network_buffer;
        void ecrire();

private:
     void handle_read(const boost::system::error_code& error, size_t number_bytes_read);
     void handle_write(const boost::system::error_code& error);
     std::string m_message;
     tcp::socket m_socket;
};

connexion.cpp cot� client

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
connexion::connexion(boost::asio::io_service& io_service) : m_socket(io_service)
{
}
 
tcp::socket& connexion::socket()
{
    return m_socket;
}
 
void connexion::read()
{
     boost::asio::async_read(m_socket, boost::asio::buffer(m_network_buffer),
     boost::asio::transfer_at_least(20),
     boost::bind(&connexion::handle_read, shared_from_this(),
     boost::asio::placeholders::error,
     boost::asio::placeholders::bytes_transferred));
}
 
void connexion::handle_read(const boost::system::error_code& error, size_t number_bytes_read)
{
    if (!error)
    {
        std::cout.write(&m_network_buffer[0], number_bytes_read);
        read();
    }
    else
    {
        std::cout<<error.message();
    }
}
 
void connexion::ecrire()
{
    m_message = "Message venant du client";
    boost::asio::async_write(m_socket, boost::asio::buffer(m_message), boost::bind(&connexion::handle_write, shared_from_this(), boost::asio::placeholders::error) );
}
 
void connexion::handle_write(const boost::system::error_code& error)
    {
        if (!error)
        {
            // Autres actions éventuelles
        }
    }

client.h

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class tcp_client
{
    public:
            tcp_client(boost::asio::io_service& io_service, tcp::endpoint& endpoint);

    private:
        void connect(tcp::endpoint& endpoint)
        {
            connexion::pointer new_connection = connexion::create(m_io_service);
            tcp::socket& socket = new_connection->socket();
            socket.async_connect(endpoint, boost::bind(&tcp_client::handle_connect, this, new_connection, boost::asio::placeholders::error));
            new_connection->ecrire();
        }

        void handle_connect(connexion::pointer new_connection, const boost::system::error_code& error)
        {
            if(!error)
            {
                new_connection->read();
            }
        }
        boost::asio::io_service& m_io_service;
};

**Iradrille** · 02/12/2015, 16h39

Apparemment tu �cris (cot� client) avant d'ouvrir la connexion : tu �cris dans connect au lieu de handle_connect. La connexion n'est pas encore ouverte � ce moment et donc l'�criture �choue.

Envoy� par Johnny29

client.h

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
class tcp_client
{
    public:
            tcp_client(boost::asio::io_service& io_service, tcp::endpoint& endpoint);
 
    private:
        void connect(tcp::endpoint& endpoint)
        {
            connexion::pointer new_connection = connexion::create(m_io_service);
            tcp::socket& socket = new_connection->socket();
            socket.async_connect(endpoint, boost::bind(&tcp_client::handle_connect, this, new_connection, boost::asio::placeholders::error));
 
            // écriture avant l'ouverture de la connection ici : new_connection->ecrire(); devrait être dans handle_connect();
            new_connection->ecrire();
        }
 
        void handle_connect(connexion::pointer new_connection, const boost::system::error_code& error)
        {
            if(!error)
            {
                new_connection->read();
            }
        }
        boost::asio::io_service& m_io_service;
};

[Boost Asio] Lecture du contenu de la socket

Boost C++

Vue hybride

Discussions similaires

Partager

Partager