Fermeture du client lors de la deconnection

Bonjour à tous,
J'essaye de développer une appli en c/c++ avec les socket en TCP.

Le probleme qui survient est que lorsque le serveur ferme la socket du client , le client se ferme automatiquement.
Serait-t'il possible que le client se remette a essayer de se connecter après la fermeture ?

Si oui , comment ?

Merci d'avance pour toute aide !

poster le code source.

Citation:

Envoyé par Neolex

Bonjour à tous,
J'essaye de développer une appli en c/c++ avec les socket en TCP.

Le probleme qui survient est que lorsque le serveur ferme la socket du client , le client se ferme automatiquement.
Serait-t'il possible que le client se remette a essayer de se connecter après la fermeture ?

Si oui , comment ?

Merci d'avance pour toute aide !

Commence par poster le code source autrement je pense que personne ne peut t'aider.

oui, c'est possible, il faut juste qu'il le fasse.

D'accord désolé voici le code source 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
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
92
93
94
 
 
// if we're on windows
#if defined (WIN32)
	#include <windows.h>
 
    #include <winsock2.h>
	#pragma comment(lib, "ws2_32.lib")
   typedef int socklen_t;
 
// else, if we're on Linux
#elif defined (linux)
 
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <arpa/inet.h>
	#include <unistd.h>
 
#endif
 
 
 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
 
#define PORT 4444
#define BUFSIZE 256
#define IP "127.0.0.1"
 
using namespace std;
 
int main(int argc, char const *argv[])
{
 
    // if we're on windows
    #if defined (WIN32)
        WSADATA WSAData;
        WSAStartup(MAKEWORD(2,2), &WSAData);
    #endif
 
 
	int sock,len;
	char buffer[BUFSIZE];
	struct sockaddr_in server_address;
 
	// Create the socket 
	if((sock= socket(AF_INET,SOCK_STREAM,0))== -1)
	{
		perror("socket");
		exit (EXIT_FAILURE);
	}
 
	// configuration of the connection
	server_address.sin_family = AF_INET;
	server_address.sin_port = htons(PORT);
	server_address.sin_addr.s_addr= inet_addr(IP);
 
	// Try to connect 
	while(connect(sock, (struct sockaddr*)&server_address,sizeof(server_address)) == -1)
	{
		perror("connect");
		// if we're on windows
		#if defined (WIN32)
			Sleep(20000);
		// else, if we're on Linux
		#elif defined (linux)
			sleep(20);
		#endif
	}
	int val;
    while(true)
    {
    	if((val=recv(sock,buffer,BUFSIZE,0))<0)
        {
            perror("recv");
            exit (EXIT_FAILURE);
        }
        buffer[val]='\0';
        cout<<"recu :"<<buffer<<endl;
 
        string result = "I'M ROOT";
        len = result.size();
        if(send(sock,result.c_str(),len,0)!=len)
        {
            perror("write");
            exit (EXIT_FAILURE);
        }
    }
 
	return 0;
}

Lorsqu'on ferme le serveur , le client se ferme lui aussi et renvoie le code 141 ( j'ai fais echo $? pour le savoir ).

Voici si besoin le code 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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
 
#define PORT 4444
 
#define BUFSIZE 256
 
 
using namespace std;
 
int main(int argc,char *argv[])
{
    int sockRVfd,sockCLfd;
    string buffer;
    struct sockaddr_in addressRV;
    socklen_t addressRVlen;
    struct sockaddr_in addressClient;
    socklen_t addressClientlen;
    char buf[BUFSIZE];
    char name[BUFSIZE];
    // Create the rendez vous socket
    if((sockRVfd = socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        perror("socket");
        exit (EXIT_FAILURE);
    }
 
    if(gethostname(name,BUFSIZE))
    {
        perror("gethostname");
        exit (EXIT_FAILURE);
    }
    cout<<"Je m'execute sur "<<name<<"."<<endl;
 
    // Prepare the local address
    addressRV.sin_family = AF_INET;
    addressRV.sin_port = htons(PORT);
    addressRV.sin_addr.s_addr = htonl(INADDR_ANY);
 
    addressRVlen = sizeof(addressRV);
 
    // bind socket to local address
    if( bind(sockRVfd , (struct sockaddr*)&addressRV,addressRVlen) == -1 )
    {
        perror("bind");
        exit (EXIT_FAILURE);
    }
 
    // start listening
    if(listen(sockRVfd,10)==-1)
    {
        perror("listen");
        exit (EXIT_FAILURE);
    }
 
    // Waiting for client
    cout<<"Attente d'un client..."<<endl;
    addressClientlen = sizeof(addressClient);
    sockCLfd = accept(sockRVfd,(struct sockaddr*)&addressClient,&addressClientlen);
    if(sockCLfd == -1)
    {
        perror("accept");
        exit (EXIT_FAILURE);
    }
   struct sockaddr_storage addr;
   socklen_t len;
   char ipstr[INET6_ADDRSTRLEN];
 
   len = sizeof addr;
   getpeername(sockCLfd, (struct sockaddr*)&addr, &len);
 
   // deal with both IPv4 and IPv6:
   if (addr.ss_family == AF_INET) {
       struct sockaddr_in *s = (struct sockaddr_in *)&addr;
 
       inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);
   } else { // AF_INET6
       struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
       inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);
   }
 
 
    // A client just arrives he is connected with sockCLfd0
    cout<<"Un client vient de se connecter."<<endl;
    cout<<"Son IP est : "<<ipstr<<endl;
    // This is a server for test so it can treat only one client
    close(sockRVfd);
/*
    if(read(sockCLfd,buf,BUFSIZE)<0)
    {
        perror("read");
        exit (EXIT_FAILURE);
    }
*/
    int val=0;
  //  cout<<"Le client s'appelle "<<buf<<endl;
    while(true)
    {
        cout<<"Entrez la commande a executer"<<endl;
        cin>>buffer;
        if(buffer=="q")
        {
            break;
        }
        buffer = "sh:"+buffer;
        val = buffer.size();
        if(send(sockCLfd,buffer.c_str(),val,0)!=val)
        {
            perror("write");
            exit (EXIT_FAILURE);
        }
        cout<<"Command sent...\nwaiting for response..."<<endl;
 
        if((val=recv(sockCLfd,buf,BUFSIZE,0))<0)
        {
            perror("read");
            exit (EXIT_FAILURE);
        }
        buf[val]='\0';
        cout<<"Reponse:\n"<<buf<<endl;
 
    }
    close(sockCLfd);
    cout<<"Server stopped"<<endl;
 
}

_ _ _

Je ne suis pas sur de ce que je dit mais bon:
Dans ton code client lorsqu'il y a une erreur dans l'envoie ou la réception de donnée, ton programme s'arrete (exit( ...)), au lieu de quitter en renvoyant qu'une erreur s'est produite essaye d'insérer un mécanisme te permettant de ré-exécuter tout le code depuis le début, genre une boucle ou au pire la récursivité sur la fonction principal "main" et si sa ne marche toujours pas un try catch fera l'affaire. :aie:

Merci pour les piste je vais essayer ça .
Juste une question pourquoi j'obtient le code de retour 141 et pas -1 comme ca devrait ?