Fonction accept() bloquante avec winsock2

**Liftu** · 06/08/2017, 17h25

Bonjour,

J'ai suivis le cours de Bousk sur winsock, et celui-ci m'as beaucoup plu.
Cependant, j'ai un soucis dans un programme et j'aurais aimé savoir si quelqu'un avait une solution à me proposer :

dans mon application serveur, j'utilise un thread qui accepte les clients en continue pour ne pas bloquer l'application. Malheureusement lorsque je souhaite éteindre l'application et que du coup j'appelle thread.join() pour attendre la fin du thread, l'application reste bloqué car le thread ne se termine pas car il est bloqué sur la fonction accept() jusq'à ce qu'un client tente de se connecter au serveur.

Quelqu'un connait-il une solution pour rendre la fonction accept() non bloquante, avec un timeout par exemple?

Merci,

Louis

**Médinoc** · 07/08/2017, 10h57

Tu peux utiliser select(), et ne faire le accept() que si select() retourne l'info comme quoi il y a un client à accepter.

**Bousk** · 07/08/2017, 11h31

Salut,

la mise en place du mode non bloquant est identique chez le client et le serveur.
Tu peux
- utiliser select pour vérifier que le socket est prêt en lecture;
- préférer poll toujours pour vérifier l'état de la lecture;
- mettre en place le vrai mode non bloquant avec des sockets non bloquants.
Si tu utilises un socket non bloquant, accept retournera directement INVALID_SOCKET s'il n'y a aucun client à accepter. http://bousk.developpez.com/cours/re...veur/#LIII-D-3
Toutes ces techniques sont dans le même article Envoi et réception depuis le serveur.

Sinon, tu peux aussi simplement fermer le socket avant d'appeler join. Ca devrait débloquer accept qui retournera alors INVALID_SOCKET.

**Liftu** · 07/08/2017, 11h38

Super, merci pour vos réponse!
Je vais essayer tout de suite.

**Liftu** · 07/08/2017, 13h46

Ça fonctionne bien en fermant le socket, merci.

Je me pencherait sur le select plus tard car il m'as l'air bien plus complexe, j'ai eu du mal à comprendre lors de m'a première lecture.

**Liftu** · 07/08/2017, 14h44

Par contre savez-vous pourquoi mon thread est non joignable?
J'obtiens une exception quand j'appelle join() qui 'm’indique que le thread n'est pas joignable.

**Bousk** · 07/08/2017, 15h31

Pour ça il faudrait savoir ce que tu fais avec ton thread.

**Liftu** · 07/08/2017, 19h42

Je créer un objet Serveur. Quand j'appelle sa méthode AcceptClients(), la méthode lance le thread qui se met alors à accepter des clients et à en stocker les sockets dans un vector en y ayant accès par référence, et tout ça en continue via une boucle while(bool).
Lorsque j'appelle la méthode Stop() du serveur, celui-ci change la valeur du booléen, ferme le socket puis appelle la méthode join() du thread

Et c'est à l'appel de join() que le programme plante et me sort cette erreur :

terminate called after throwing an instance of 'std::system_error'
what(): Invalid argument

**Médinoc** · 07/08/2017, 23h51

Fais gaffe, while(bool) n'est pas garanti marcher. S'il est déclaré volatile en plus, c'est garanti sur certaines plate-formes (dont Windows).

Aussi, peut-on voir le code qui lance le thread et le code qui appelle join()?

**Bousk** · 08/08/2017, 09h46

T'es sûr que t'as pas déjà détaché ou join le thread ?
Ce que tu décris est exactement ce que je fais dans chacun de mes programmes et fonctionne parfaitement.

Y'a pas 500 façons d'avoir cette exception, ton thread n'est pas joignable.
http://www.cplusplus.com/reference/t...read/joinable/

**Liftu** · 08/08/2017, 15h31

La fonction AcceptClients(), que j'appelle au début de mon programme :

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
 
void Server::AcceptClients(std::vector<Client> &clients)
{
    m_isClientsAccepted = true;
    SOCKET *socket = &m_socket;
    bool *isClientsAccepted = &m_isClientsAccepted;
    m_threadAccept = std::thread([isClientsAccepted, socket, &clients]()
    {
        while(isClientsAccepted)
        {
            sockaddr_in from = { 0 };
            int addrlen = sizeof(from);
            SOCKET newClient = accept(*socket, (SOCKADDR*)(&from), &addrlen);
 
            if (newClient != INVALID_SOCKET)
            {
                clients.push_back(Client(newClient, Sockets::GetAddress(from), ntohs(from.sin_port)));
            }
            /*else
            {
                break;
            }*/
        }
    });
}

Pour information la classe Client contient juste un socket, une ip, et un port. Elle sert à stocker ces informations de manière simple dans un vector.

Et la fonction Stop(), que j'appelle à la fin de mon programme :

Code :

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

1
2
3
4
5
6
7
8
 
bool Server::Stop()
{
    m_isClientsAccepted = false;
    bool ret = Sockets::CloseSocket(m_socket);
    m_threadAccept.join();
    return ret;
}

Alors je ne sait pas si c'est une bonne idée d'avoir fait passer mes variable de la classe Server par des pointeurs(m_socket, et m_isClientsAccepted), mais sinon le compilateur me retournée une erreur que je ne comprenais pas avec lambda ou je ne sais quoi...

**Bousk** · 08/08/2017, 16h12

Le passage par copie de pointeur est pas terrible en effet, tu pourrais simplement passer this. Ta variable m_isClientsAccepted est assez trompeuse aussi mais rien de dramatique.
Es-tu sur de ne pas simplement appeler Close plusieurs fois ? Ou sans appeler AcceptClients au préalable et donc tu as un std::thread default-constructed qui n'est pas joinable.