Socket, errno 24 sur accept()

Version imprimable

17/12/2014, 22h30
moi4567

Socket, errno 24 sur accept()

Hello :)

Je travail actuellement sur un programme client/serveur et je fait des tests de reconnection. Pour ne pas trop rentrer dans les détails, je lance mon programme client, je lance le serveur, et je les interromps l'un et l'autre en les relançants pour vérifier que le client se reconnecte bien au serveur après une déconnections et inversement.

Lorsque j'interromps le client et que je le relance, aucun soucis, le serveur le reprend sans problème, mais lorsque j'interromps le serveur et que je le relance j'ai un errno 24 sur la fonction accept() (côté serveur). Je n'ai cette erreur seulement lorsque j'interromps, puis, relance le serveur tout en laissant le client ouvert. Là où je suis un peu étonné c'est que dans un cas "normal" où je lance le serveur et le client pour la première fois je n'ai pas cette erreur.

J'ai fait quelques recherches mais je n'ai malheuresement rien trouvé qui ne fonctionne :?.

Avez-vous déjà rencontré cette erreur? :o

Merci d'avance ;)
18/12/2014, 08h25
SkyZoThreaD

L'erreur 24 sur accept signifie "too many open files". Essaye de vérifier que le socket est bien fermé quand tu interrompt le serveur. Si oui, donnes-nous le code qui est sensé faire ce taf ;)
18/12/2014, 14h06
bacelar

24 ou 0x24 ?

Citation:

ERROR_BAD_LENGTH
24 (0x18)
The program issued a command but the command length is incorrect.

Citation:

ERROR_SHARING_BUFFER_EXCEEDED
36 (0x24)
Too many files opened for sharing.

@SkyZoThreaD: J'ai bien vérifié, la socket est fermé avant de relancer le serveur mais j'ai toujours la même erreur.

@bacelar Effectivement tu as bien fait de demander, c'est un errno 0x18 (j'avais pas tilté que c'était en hexadécimal ^^').

Du coup, voici une partie de mon code source:

main.cpp

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
#include <iostream>			
#include <thread>			
 
#include "socket.h"
 
using namespace std;
 
int main()
{
    while (sock_s.sock_listen == -1)
    {
    	sock_s.sock_listen = socket_creation();     //crée la socket
    } 
 
    thread T1_accept(socket_chain_accept, sock_s.sock_listen);    //thread acceptant les connexions
    thread T2_check(socket_check);      //thread vérifiant la connexion client en envoyant un message (send())
 
    string data;
    while (1)
    {
    	sleep(1);
    	cout << "Wait client..." << endl;
    	while (sock_s.csock.size() != 0)     //Si il y a un client de connecté...
    	{
    		cout << "Message : ";
    		cin >> data;
    		if(data == "exit")
    		{
    			shutdown(sock_s.sock_listen, 2);
    			close(sock_s.sock_listen);
    			T1_accept.detach();
			T2_check.detach();
 
			cout << "FINISH" << endl;
    			return 0;
    		}
   		socket_send((char*)data.c_str(), sock_s.csock[0]);
    	}
    }
 
    return 0;
}

socket.h

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
typedef int SOCKET;
 
struct sock_s
{
	SOCKET sock_listen = -1;
	vector<SOCKET> csock;
}sock_s;
 
int socket_listen(SOCKET sock = sock_s.sock_listen, int max_connection = 5)
{
    if(listen(sock, max_connection) == -1)
    {
        cout << "ERROR : Socket listen failed!" << endl << "      : errno = " << errno << endl;
        return -1;
    }
 
    sockaddr_in target;
 
    socklen_t _size = sizeof(sock);
    SOCKET csock = accept(sock, (sockaddr*)&target, &_size);
 
    if(csock == -1)
    {
        cout << "ERROR : Socket accept connection failed!" << endl << "      : errno = " << hex << errno << endl;
        return -1;
    }
 
    return csock;
}
 
void socket_chain_accept(SOCKET sock = sock_s.sock_listen)
{
	SOCKET csock;
	while(1)
	{
		csock = socket_listen(sock_s.sock_listen, 999);
		if(csock != -1)
		{
			sock_s.csock.push_back(csock);
		}
	}
}

Je n'ai mis ici que les partis me parraissant interessantes pour facilité la lisibilité mais si vous voulez voir l'intégralité il n'y a pas de soucis :)

18/12/2014, 19h35
SkyZoThreaD

Dans socket_listen tu as:

Code:

socklen_t _size = sizeof(sock);

la taille d'un int ?!?!
Je mettrai plus:

Code:

socklen_t _size = sizeof(target);

Un sockaddr aurait du mal a tenir dans un int à mon avis...
mais bon je ne suis pas un expert...
18/12/2014, 19h47
bacelar

Houlà, ça manque de rigueur.
Si ça marche, c'est que c'est tombé en marche.

Il ya tellement de truc étrange que je pense qu'il faudra commencer par remettre tout un peu plus d'équerre.

1- C'est quoi ce .h avec des définitions ?
Dans les .h, c'est les déclarations.

2- C'est quoi ces "while tant qu'erreur" et autre while(1) ???

3- dégagez moi ces Sleep !

4- C'est quoi cette valeur par défaut de paramètre correspondant à un champ du variable globale ? Je savais même pas que ça pouvais compiler tellement c'est illogique.

...

Il faut être rigoureux quand on programme mais encore plus quand on fait du multi-threading.
C'est tellement fouillis qu'on ne peut pas raisonnablement appréhender les mécanismes de synchronisation des threads.

P.S.: SkyZoThreaD a tout à fait raison, je l'avais vu, mais il y a tellement de chose d'autres qui ne vont pas pour comprendre comment, par miracle, ça ne plante pas, que j'ai oublié de le rajouter.
18/12/2014, 20h43
moi4567

Effectivement c'est plus logique comme ça ^^' Je suis en train d'apprendre à manier les sockets et ça ne m'avait pas marqué mais maintenant que tu le dit ça parrait évident. Merci pour la correction :)

J'ai donc changé ça mais j'ai toujours le même problème :/
Je continu à faire des recherches sur l'erreur errno.

EDIT: Désolé bacelar je n'avais pas vu ton message. Je vais faire du ménage et je vous redonne tout ça. Et à propos des sleep ils me permettent de prendre le temps de voir les messages d'erreurs sans que ça ne défile à une vitesse folle. Bon si je n'avais pas mis des while(1) je n'aurais peut être pas ce problème... Certe ^^' Bon je vais faire du ménage et je reviens :)
18/12/2014, 21h26
SkyZoThreaD

Si l'erreur est bien:

Citation:

ERROR_BAD_LENGTH
24 (0x18)
The program issued a command but the command length is incorrect.

Alors la correction que je t'ai donné était peut-être la cause de l'erreur 0x18
Mais tu as peut-être un(ou des) autre souci ailleurs.
Evite l'utilisation de threads si tu n'es pas famillier avec eux. Mon pseudo veut tout dire (même s'il ne veux aussi rien dire:mrgreen:).
Il y a les problèmes de sychro, de partage de ressources... c'est vraiment pas simple. Tu n'as pas moyen de faire sans?
Bon courage en tout cas on attend ton code retravaillé ;)
18/12/2014, 21h44
moi4567

Hum... Enfaite j'ai besoin de thread infini, pour pouvoir vérifier en permanence la liste des clients et je n'ai pas trouvé le moyen de relancer le thread une fois terminé sans boucle infini :/ Bref, je vais revoir ça :)

Après pour l'erreur j'ai toujours la même avec ou sans ta correction mais quoi qu'il en soit j'avais bel et bien une erreur à ce niveau là (et pas que :roll: )
20/12/2014, 16h24
poukill

Citation:

Envoyé par moi4567

Hum... Enfaite j'ai besoin de thread infini

En dehors du contexte, ça fait peur ce genre de remarque ! :aie:
Mais bon, on comprend quand même ! ;)
20/12/2014, 18h00
Bousk

Salut,

tu as cette erreur sur le serveur, mais est-ce que le client réagit bien au reboot serveur ?
Est-ce qu'il ferme correctement sa socket avant d'en réouvrir une vers le serveur ?

Sinon, je vois pas ce qu'il y a de choquant à voir des boucles infinies dans du code réseau... c'est même assez habituel et normal. :weird:

Je n'ai malheureusement plus de code serveur en C++ à te montrer. :?
Mais en gros, tu devrais avoir un thread qui écoute les connections, et un autre qui gère les clients.
Le main thread peut s'occuper des connections.
Après, vu ton faible nombre de clients, tu peux threader chacun d'eux sur le serveur.

Par contre, quitte à vouloir faire du C++, fais vraiment du C++..
Une classe serveur, c'est un bon début.

En plus, il manque la moitié du code.
socket_creation par exemple, on le devine comment ?
22/12/2014, 14h34
SkyZoThreaD

Citation:

Sinon, je vois pas ce qu'il y a de choquant à voir des boucles infinies dans du code réseau... c'est même assez habituel et normal.

Des boucles infinies ok (sans while(1) quand même). Mais la boucle principale dans un thread c'est moyen. Le concept veut plus qu'elle soit dans le main thread et chaque client lance un thread à la connexion. non?

edit: oops parlé trop vite. C'est bien ce que tu as dit :aie: