envoi msg server erroné

Version imprimable

Bonjour,

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

j'essaie d'envoyer un joli petit "hello world" et tout ce que je reçois c'est "hell" :aie:
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:

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:

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:

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.......... [ -] ) :lol:

Salut,
Citation:
Envoyé par Kaamui
Code:

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:

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

Citation:

Envoyé par Kaamui

Code:

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

:fessee:
On ne fait pas de malloc en C++

Citation:

Envoyé par 3DArchi

:fessee:
On ne fait pas de malloc en C++

:calim2:

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

:D

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:

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.

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:

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:

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 ?

04/12/2011, 17h21
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.
04/12/2011, 22h16
Kaamui

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

Cordialement,