Erreur 10035 sur recv()

Bonjour !

Voici la structure:

Serveur 1, ecoute sur 5001
Serveur 2, ecoute sur 5002 et se connecte a 5001 pour papoter avec le serveur 1
Client(s), se connecte a 5001.

Les serveurs arrivent a parler entre eux, aucun probleme.
En revanche, lorsque le client envoie des données (oui le send marche bien), he bien du coté du server, il ne recoit pas et me renvoie 10035 :/

Voici la réception du serveur:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    while(!shutdown)
    {
        LockSharedMutex();
        if(Collection->Count() == 0) // On ne fait rien si il ny a aucun client de connecté
        {
            UnlockSharedMutex();
            continue;
        }
        if(Selectr->Select() < 0) // Si la fonction select() retourne -1..
        {
            int e = WSAGetLastError();
            if (e != 0)
            {
 
                std::cout << "WSA Error: " << e << std::endl;
                UnlockSharedMutex();
                //continue;
                exit(0);
            }
            UnlockSharedMutex();
            continue;
        }
        for(auto itr = Collection->AllSessions().begin(); itr != Collection->AllSessions().end(); ++itr) // boucle sur tout les clients connectés
        {
            Target = itr->second;
            if(Selectr->Ready(Target->GetSocket())) // alias de la fonction FD_SET(sock,&fs)
            {
                if(!ReceiveHeader(Target->GetSocket())) // recv()
                {
                    if(BytesReceived < 0)
                    {
                        if(ErrorNumber == 10035)
                        {
                            //continue;
                        }
                        else
                        {
                            Selectr->Delete(Target);
                            continue;
                        }
                    }
                    else
                    {
                        Selectr->Delete(Target);
                        continue;
                    }
                }
                else
                {
                    plength = (static_cast<int>((((Packet::htos(Header[0], 4) | Packet::htos(Header[1], 0)) & 0xff) << 8) & 0xffff | ((Packet::htos(Header[3], 4) | Packet::htos(Header[4], 0)) & 0xff)))+1;
                    if(plength > 1)
                    {
                        if(!Receive(Target->GetSocket(), plength)) // recv()
                        {
                            if(BytesReceived < 0)
                            {
                                if(ErrorNumber == 10035)
                                {
                                    continue;
                                }
                                else
                                {
                                    std::cout << "Error reading packet " << ErrorNumber << std::endl;
                                    Selectr->Delete(Target);
                                    continue;
                                }
                            }
                            else
                            {
                                Selectr->Delete(Target);
                                continue;
                            }
                        }
                        else
                        {
                            std::cout << "received::" << Buffer << std::endl;
                            Target->handleRequest(Buffer);
                            continue;
                        }
                    }
                    else
                    {
                        Selectr->Delete(Target);
                        continue;
                    }
                }
            }
        }
        Selectr->Flush();
        UnlockSharedMutex();
    }

Voici le client que le serveur 2 possède:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ClientSocket::ClientSocket(const string& ip, int port)
{
    csi.ip = ip;
    csi.port = port;
	if ((csi.sock = socket(AF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
	{
		exit(EXIT_FAILURE);
	}
	csi.sain.sin_family=AF_INET;
    //cout << "## Initializing the client socket" << endl;
    csi.sain.sin_addr.s_addr=inet_addr(csi.ip.c_str());
    csi.sain.sin_port=htons(csi.port);
    if(connect(csi.sock,(struct sockaddr*)&csi.sain,sizeof(csi.sain)) != 0)
    {
        cout << "ERROR: Could not connect to " << csi.ip << ":" << csi.port << endl;
        exit(0);
    }
    csi.connected = true;
}

Voici le socket du client:

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
52
53
54
55
56
57
58
59
60
61
62
 
ClientSocket::ClientSocket(const int proto)
{
    #if defined (WIN32)
    WSADATA WSAData;
    int error = WSAStartup(MAKEWORD(2,2), &WSAData);
    #else
    int error = 0;
    #endif
    int sock_err;
 
    if(error)
    {
        std::cout << "ERROR: Starting up socket" << std::endl;
        exit(0);
    }
 
    csi.proto = protocol;
    csi.connected = false;
    csi.sock = 0;
 
	if ((csi.sock = socket(AF_INET, csi.proto, 0)) == INVALID_SOCKET)
	{
		exit(EXIT_FAILURE);
	}
}
bool ClientSocket::Connect(const std::string& ip, const int port)
{
    if(csi.connected) // re-connection
    {
        Disconnect();
        delete selector;
        selector = NULL;
        delete handler;
        handler = NULL;
    }
    selector = new Selector(); // alias pour les fonctions select, & FD*
    handler = new PacketHandler(this); // pas important
    csi.ip = ip;
    csi.port = port;
    if ((csi.sock = socket(AF_INET, csi.proto, 0)) == INVALID_SOCKET)
	{
	    std::cout << "Could not create socket" << std::endl;
		return false;
	}
	csi.sain.sin_family = AF_INET;
    csi.sain.sin_addr.s_addr = inet_addr(csi.ip.c_str());
    csi.sain.sin_port = htons(csi.port);
 
    if(connect(csi.sock, (struct sockaddr*)&csi.sain,sizeof(csi.sain)) != 0)
    {
        std::cout << "Could not connect to server" << std::endl;
        return false;
    }
 
    csi.connected = true;
    selector->Add(csi.sock); // on ajoute le socket au selecteur de fichier
 
    pthread_create(&t_networker, NULL, Networker, this); // le thread de reception
 
    return true;
}

Et j'appelle donc de cette facon:

Code:

1
2
ClientSocket* a = new ClientSocket(SOCK_STREAM);
a->Connect("127.0.0.1", 5001);

La connexion est bonne, la deconnexion egalement (cote serveur ou client, elle est bien gerée)
en revanche, le serveur donc, bah. Erreur 10035 quand jenvoie des données .... :/

Quelqu'un a - t - il une idée?

http://geekswithblogs.net/Lance/arch...rror10035.aspx
http://bobobobo.wordpress.com/2008/1...saewouldblock/

Merci mais avant de poster j'ai du consulter ces sites au moins 10 fois.
Je vois pas en quoi ca a un rapport avec mon truc, mais bon :v

C'est compliqué de voir ce qui ne va pas avec ce que tu nous donnes.

La connexion a bien été "acceptée" ?
Ton "select" est bien configurer pour prendre en compte toutes les (2) connexions (client/serveur1 et serveur1/serveur2) ?

Citation:

Envoyé par DakM

Merci mais avant de poster j'ai du consulter ces sites au moins 10 fois.
Je vois pas en quoi ca a un rapport avec mon truc, mais bon :v

A part que c'est le meme nessage d'erreur sur le meme type d'application?
Apparemment, ta socket sur le serveur est marquee non bloquante. Il semble que l'erreur WSA_EWOULDBLOCK signifie simplement qu'aucune donnee n'est disponible et que le serveur devrait attendre que des donnees arrivent pour que recv fonctionne.

La solution serait de configurer ta socket sur le serveur en bloquante (donc elle attendra des donnees a chaque fois que tu appelles recv) ou de considerer WSA_EWOULDBLOCK comme un message "aucune donnee disponible pour l'instant", laisser le programme faire autre chose et revenir voir si des donnees sont disponibles plus tard.

Tout ce qui est explique dans mon deuxieme lien, quoi.