Discussion :

[Kaamui]

Bonjour,

viola j'ai tenté de faire mon premier programme réseau, et ça fonctionne plutôt bien, mais plutôt seulement ...


j'essaie d'envoyer un joli petit "hello world" et tout ce que je reçois c'est "hell"
Je sais pas si Satan essaie de m'envoyer un message, mais sinon on dirait bien que mon programme ne peut pas envoyer plus de 4 caractères...

je penses que c'est une erreur classique, genre problème de copie ou autre, mais je vous avoue que je comprend pas.

server.hpp :

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
 
#ifndef DEF_SERVER_HPP
#define DEF_SERVER_HPP
 
 
#include <SFML/Network.hpp>
#include <iostream>
#include <string>
 
typedef std::pair <sf::Socket::Status, sf::SocketTCP> infoSocketClient;
 
class Server
{
    public :
        Server(sf::SocketTCP listener, unsigned short port);
        ~Server();
        infoSocketClient WaitForConnection(std::string *clientAddress);
        sf::SocketTCP GetListener();
        unsigned short GetPort();
        void ReceiveMsg(sf::SocketTCP* Client);
 
 
 
    private :
    void error(std::string msg, int* valeur=NULL)
    {
        if (valeur==NULL)
            std::cout << msg << std::endl;
        else
            std::cout << msg << *valeur << std::endl;
    }
 
        sf::SocketTCP listener;
        unsigned short port;
 
};

client.hpp

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
 
#ifndef DEF_CLIENT_HPP
#define DEF_CLIENT_HPP
 
#include <SFML/Network.hpp>
#include <iostream>
 
class Client
{
    public :
        Client(unsigned short port, sf::SocketTCP client,  sf::IPAddress serverAddress);
        ~Client();
        sf::Socket::Status ConnectToServer();
        void SendMsg(char* msg);
 
 
    private :
        void error(std::string msg, int* valeur=NULL)
        {
            if (valeur==NULL)
                std::cout << msg << std::endl;
            else
                std::cout << msg << *valeur << std::endl;
        }
        unsigned short port;
        sf::SocketTCP client;
       sf::IPAddress serverAddress;
 
 
};
 
#endif

et voila ce qui peut être utile :

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
51
 
void Client::SendMsg(char* msg)
{
    if (client.Send(msg, sizeof(msg)) != sf::Socket::Done)
    {
        // Erreur...
    }
}
 
void Server::ReceiveMsg(sf::SocketTCP* Client)
{
    char message[128];
    std::size_t Received;
    switch (Client->Receive(message, sizeof(message), Received))
    {
        case sf::Socket::Done :
            std::cout << message << std::endl;;
            break;
        case sf::Socket::NotReady :
            error("pas de connexion");
            break;
        case sf::Socket::Error :
            error("erreur de connexion");
            break;
        case sf::Socket::Disconnected :
            error("deconnecte");
            break;
        default : break;
    }
 
}
 
et dans mon main : 
 
//cote client
std::string test;
        cout << "message ? ";
        cin >> test;
        char *Msg = (char*)malloc(sizeof(test));
        strcpy(Msg, test.c_str());
 
        client.SendMsg(Msg);
 
 
//cote server
        infoSocketClient info = server.WaitForConnection(&addresse);
 
        if ( info.first == sf::Socket::Done)
        {
            server.ReceiveMsg(&info.second);
        }

voila je suis à votre écoute ... (bande de ports.......... [ -] )

[3DArchi]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void Client::SendMsg(char* msg)
{
    if (client.Send(msg, sizeof(msg)) != sf::Socket::Done)
    {
        // Erreur...
    }
}

La taille d'un pointeur (sizeof(msg)) est 4 quelque soit l'élément pointé .. d'où "hell".

Utilises des interfaces correctement typées :

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
 
void Client::SendMsg(std::vector<unsigned char> const &msg)
{
    if (client.Send(&msg[0],msg.size()) != sf::Socket::Done)
    {
        // Erreur...
    }
}
 
void Server::ReceiveMsg(sf::SocketTCP* Client)
{
    std::vector<unsigned char> message(128);
    std::size_t Received;
    switch (Client->Receive(&message[0], message.size(), Received))
    {//... }
 
}

Après, il me semble que la sfml t'offre des choses plus évoluées

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *Msg = (char*)malloc(sizeof(test));

On ne fait pas de malloc en C++

[Kaamui]

On ne fait pas de malloc en C++

j'ai pas fait exprèèèèès j'étais désespéré il était 4h du mat...



Non mais merci pour tes remarques, en effet, sizeof(truc*) j'ai fais un bête copié collé j'aurais mieux fais de réfléchir.

maintenant j'ai ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void Client::SendMsg(std::string msg)
{
    if (client.Send(msg.c_str(), msg.size()) != sf::Socket::Done)
    {
        // Erreur...
    }
}
 
 
std::string msg;
        cout << "message ? ";
        cin >> msg;<---ne récupère que les caractères avant un espace
        client.SendMsg(msg);

je dépasse les 4 caractères mais maintenant je ne dépasse pas les espaces...une idée ?


Edit : ok il fallait pas utiliser cin qui s'arrête pas seulement quand il rencontre la touche entrée mais aussi les espaces. Pour contrer ça : getline.

[Kaamui]

alors en fait mon problème est différent, maintenant,
je n'arrive pas à vider l'entrée standard : je m'explique :

je boucle pour que le client puisse envoyer autant de message qu'il veut et j'ai plusieurs problèmes :

envoi : test
envoi : a

va donné du coté serveur :

reçu : test
reçu : aest

Ensuite :

envoi : j'ai
reçu : j'ai^¨ (en fait c'est d'autre caractère mais bref...)

voici ce que je fais dans mon main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
//cote client : 
std::string msg;
        message ("connexion reussie\n");
        cin.ignore();
        while (msg != "exit")
        {
            cout << "envoi :";
            getline(cin, msg);
            client.SendMsg(msg);
        }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
//cote serveur
while (continuer==true)
{
     continuer = server.ReceiveMsg(&info.second, addresse);
}

je sais bien que c'est mon utilisation de getline et/ou de cin qui déconne mais je suis perdu, comment je vide le buffer correctement, et comment je redimensionne std::string msg ?

[3DArchi]

Le '\0' de terminaison de chaîne C n'est pas transmis puisque la taille d'une std::string c'est son nombre exact de caractère. Tu dois soit le transmettre côté émetteur soit le rajouter explicitement côté récepteur.

[Kaamui]

Merci beaucoup 3DArchi, encore une fois tu as tapé dans le mille.

Cordialement,