#include <iostream>
#include <SFML/Network.hpp>
#include <list>

int main()
{
    // Create a socket to listen to new connections
    sf::TcpListener listener;
    listener.listen(5000);
    // Create a list to store the future clients
    std::list<sf::TcpSocket*> clients;
    // Create a selector
    sf::SocketSelector selector;
    // Add the listener to the selector
    selector.add(listener);
    // Endless loop that waits for new connections
    while (true)
    {
        // Make the selector wait for data on any socket
        if (selector.wait())
        {
            // Test the listener
            if (selector.isReady(listener))
            {
                // The listener is ready: there is a pending connection
                sf::TcpSocket* client = new sf::TcpSocket;
                if (listener.accept(*client) == sf::Socket::Done)
                {
                    // Add the new client to the clients list
                    clients.push_back(client);
                    // Add the new client to the selector so that we will
                    // be notified when he sends something
                    selector.add(*client);
                    sf::Packet packet;
                    std::string str = "Serveur : Un nouveau client s'est connecté.\n";
                    printf("%s",str.c_str());
                    packet << str;
                    int i=0;
                    for (std::list<sf::TcpSocket*>::iterator it = clients.begin(); it != clients.end(); ++it)
                    {
                        sf::TcpSocket& client = **it;
                        if (!(client.send(packet) == sf::Socket::Done))
                        {
                            printf("Le paquet contenant \"un nouveau client vient de se connecter n'a pas pu être envoyé au client %d\n\"",i);
                        }
                        else printf("Le paquet contenant l'info de nouvelle connexion a bel et bien été envoyé au client %d.\n");
                        i++;
                    }
                    
                }
                else
                {
                    printf("La connexion n'a pas pu être établie.\n");
                    // Error, we won't get a new connection, delete the socket
                    delete client;
                }
            }
            else
            {
                // The listener socket is not ready, test all other sockets (the clients)
                printf("On a reçu des données d'autre chose qu'en provenance du listeneur.\n");
                int j = 0;
                for (std::list<sf::TcpSocket*>::iterator it = clients.begin(); it != clients.end(); ++it)
                {
                    sf::TcpSocket& client = **it;
                    if (selector.isReady(client))
                    {
                        printf("On a reçu des paquets venant du client %d\n", j);
                        // The client has sent some data, we can receive it
                        sf::Packet packet;
                        if (client.receive(packet) == sf::Socket::Done)
                        {
                            std::string msg;
                            packet >> msg;
                            std::cout << msg;
                            
                        }
                    }
                    j++;
                }
            }
        }
    }
}

-
Edité par Pauda 29 novembre 2014 à 8:46:32

// Create a selector
sf::SocketSelector selector;
// Add the listener to the selector
selector.add(listener);
// Endless loop that waits for new connections

Tu dois recréer le selector à chaque fois que tu veux t'en servir. Donc crée-le dans la boucle.

Bonjour et merci pour ta réponse.

J'ai essayé ce que tu viens de proposer mais cela ne fonctionne pas. Et c'est normal : si je réinitialise le selector à chaque tour de boucle, il n'y a aucune raison pour qu'il se souvienne des sockets enregistrés précédemment. Par conséquent mon serveur ne peut pas communiquer avec les clients puisqu'il efface tous les canaux de communications (sockets) avec eux de sa mémoire à chaque tour de boucle.

De plus l'auteur de la documentation n'a pas mis le selector dans la boucle.

Je crois donc ne pas comprendre ce que tu veux dire. Pourrais-tu me détailler un peu plus ta pensée ?

-
Edité par Pauda 2 décembre 2014 à 12:52:18

Oups ! En effet je me suis totalement trompé ! J'ai confondu avec autre chose...

Pour en revenir à ton problème, je t'avoue ne pas vraiment le comprendre. Il te suffit de boucler sur tes clients et d'envoyer le message sur client_courant != client_qui_a_recu_le_message.

PS: pourquoi utilises-tu printf dans du C++ alors que tu utilises cout à certains endroits ? printf c'est du C, ça n'a rien à faire dans ce code.

Pour le printf, c'est juste parce que par le passé j'ai plus souvent eu l'occasion de faire du C que du C++ et du coup c'est un vieux réflexe. En effet je peux tout remplacer par des cout.

En fait ce que je veux comprendre c'est pourquoi ce code ne fait pas ce que je veux.
Et ce que je veux c'est que dès qu'un client envoie un message le serveur le réceptionne et l'affiche dans sa console.
Mais en l'occurrence je dois attendre qu'un nouveau client se connecte pour que le serveur affiche le message du premier client dans sa console.
Je ne m'explique pas ce phénomène. J'ai pas mal essayé de modifier mon code mais rien n'y fait.

Pauda a écrit:

En fait ce que je veux comprendre c'est pourquoi ce code ne fait pas ce que je veux.

ligne 75

std::cout << msg;

rajoute un std::flush ou un std::endl

-
Edité par Dichotoman 3 décembre 2014 à 1:42:39

Qu'est ce qui ne fonctionne toujours pas? Avec qu'un seul client j'obtiens:

J'ai juste rajouter un std::endl côté serveur, et mon code client est basique:

int main()
{
    sf::TcpSocket socket;
    if(socket.connect("127.0.0.1", 5000) != sf::Socket::Done)
    {
        throw std::runtime_error("sf::TcpSocket::connect()");
    }

    std::string line;
    while(std::getline(std::cin, line))
    {
        sf::Packet packet;
        packet << line;
        if(socket.send(packet) != sf::Socket::Done)
        {
            throw std::runtime_error("sf::TcpSocket::send()");
        }
    }
}

Si j'ai plusieurs clients, dès l'envois le serveur affiche le message pas besoin qu'un nouveau client se connecte.

-
Edité par Dichotoman 3 décembre 2014 à 9:10:36

En fait c'était mon client qui avait un problème, pas mon serveur. Je te remercie franchement AlienX13.

Toutefois j'ai une dernière question. Quand depuis le logiciel client on veut fermer la connexion, alors comment le faire proprement ? Et si le client quitte subitement (par exemple si je fais CTRL+C dans le client) comment traiter ce problème avec mon serveur ? Actuellement en effet, ça fait juste boucler mon serveur infiniment sur un truc absurde. Réciproquement -mais c'est un cas plus rare en pratique- si le serveur plante, comment traiter le problème proprement depuis le client ? 

Merci encore !

-
Edité par Pauda 4 décembre 2014 à 0:14:28

Je suis débutant également donc je ne connais pas la bonne solution.

CTRL^C, est interceptable, son signal est SIGINT et tu peux appeler une fonction quand on le recoit. Une fonction qui enverrais aux clients que le serveur va très prochainement se deconnecter (tu peux faire pareil côté client).

Si le serveur se deconnecte vraiment sans t'en informer, le seul moyen de le savoir c'est lors d'un sf::TcpSocket::send() ou sf::TcpSocket::receive(),

-
Edité par Dichotoman 4 décembre 2014 à 13:20:54

Lu'!

Petit rappel - C++ est un langage à exception, il y a beaucoup trop de pointeur nu dans ce code.