Problème Client Serveur

Version imprimable

Bonjour,
Voila j'ai un problème au niveau du client et je ne sais pas vraiment pourquoi...
j'ai 3 fichiers pour le serveurs et 3 fichiers pour le client.

Le Client :
connexion.c

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
#include "connexion.h"
#include <stdio.h>
 
SOCKET initialiser ()
{	
	SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
	if(sock == SOCKET_INVALIDE)
	{
		printf("Socket invalide pour socket()\n");
		close(sock);
		exit(1);
	}
 
	return sock;
}
 
SOCKET connexion (SOCKET sock, char adress_ip[])
{
	int erreur;
	SOCKADDR_IN sin = { 0 };
	sin.sin_addr.s_addr = inet_addr(adress_ip);
	sin.sin_port = htons(10000);
	sin.sin_family = AF_INET;
	printf("essai\n");
	erreur = connect(sock, (SOCKADDR *) &sin, sizeof(SOCKADDR));
	if(erreur == ERREUR_SOCKET)
	{
		printf("Socket invalide pour connect()\n");
		close(sock);
		exit(1);
	}
 
	return sock;
}
 
void reception (SOCKET sock);

Je n'ai pas encore implémenté reception(SOCKET sock);

connexion.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
#ifndef CONNEXION_H
#define CONNEXION_H
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
typedef struct in_addr IN_ADDR;
#define SOCKET_INVALIDE -1
#define ERREUR_SOCKET -1
 
 
/*
   initialisation du socket
   retourne le socket initialisé
*/
 
SOCKET initialiser ();
 
/*
   connexion au serveur avec le socket initialisé
   retourne la connexion
*/
 
SOCKET connexion (SOCKET sock, char adress_ip[]);
 
/*
   reception des données du serveur
   ne retourne rien
*/
 
void reception (SOCKET sock);
 
#endif

main connexion :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "connexion.h"
 
int main (void)
{
	SOCKET client;
	char adress_ip[16] = "";
	printf("Adresse IP de l'ordinateur : ");
	fgets(adress_ip,sizeof adress_ip, stdin);
	client = initialiser();
	client = connexion(client,adress_ip);
 
	if(client == ERREUR_SOCKET || client == SOCKET_INVALIDE)
	{
		printf("Connexion impossible\n");
	}else{
		printf("Connexion réussie\n");
	}
 
	return 0;
}

Le Serveur :

ServeurConnexion.c :

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
#include "ConnexionServeur.h"
#include <stdio.h>
 
SOCKET initialiser()
{
	SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
	if(sock = SOCKET_INVALIDE)
	{
		printf("Socket invalide pour socket()\n");
		close(sock);
	}
 
	return sock;
}
 
SOCKET ecoute(SOCKET sock)
{
	int erreur;
	SOCKET serv_sock;
	SOCKADDR_IN sin = { 0 };
	SOCKADDR_IN serv_sin = { 0 };
	int sin_size = sizeof serv_sin;
	sin.sin_addr.s_addr = htonl(INADDR_ANY);
	sin.sin_family = AF_INET;
	sin.sin_port = htons(10000);
	erreur = bind (sock, (SOCKADDR *) &sin, sizeof sin);
	if(erreur == ERREUR_SOCKET)
	{
		printf("Socket invalide pour bind()\n");
		close(sock);
	}
	erreur = listen (sock, 1);
	if(erreur == ERREUR_SOCKET)
	{
		printf("Socket invalide pour listen()\n");
		close(sock);
	}
	serv_sock = accept (sock, (SOCKADDR *) &serv_sin, &sin_size);
	if(serv_sock == SOCKET_INVALIDE)
	{
		printf("Socket invalide pour accept()\n");
		close(serv_sock);
		close(sock);
	}
 
	return serv_sock;
}
 
void reception(SOCKET sock);

ServeurConnexion.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
#ifndef CONNEXION_H
#define CONNEXION_H
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
typedef struct in_addr IN_ADDR;
#define SOCKET_INVALIDE -1
#define ERREUR_SOCKET -1
 
 
/*
   initialisation du socket
   retourne le socket initialisé
*/
 
SOCKET initialiser ();
 
/*
   connexion au serveur avec le socket initialisé
   retourne la connexion
*/
 
SOCKET ecoute (SOCKET sock);
 
/*
   reception des données du serveur
   ne retourne rien
*/
 
void reception (SOCKET sock);
 
#endif

Le main pour le serveur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "ServeurConnexion.h"
 
int main (int argc, char ** args)
{
	SOCKET serveur;
	SOCKET discussion_client;
	serveur = initialiser();
	discussion_client = ecoute(serveur);
 
	if((discussion_client != SOCKET_INVALIDE) && (discussion_client != ERREUR_SOCKET))
	{
		printf("Connexion établie");
	}
 
	return 0;
}

Le problème est que lorsque je lance le serveur, il passe par tous les messages d'erreurs...
Je n'ai pas encore essayé le Client.

Merci d'avance pour votre aide.

Salut

C'est peut-être parce que tu as oublié d'initialiser l'API (code d'exemple MSDN de WSAStartup) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
 
/* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
    wVersionRequested = MAKEWORD(2, 2);
 
    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
        /* Tell the user that we could not find a usable */
        /* Winsock DLL.                                  */
        printf("WSAStartup failed with error: %d\n", err);
        return 1;
    }

25/03/2010, 00h12
guy_s

Non du tout, de plus je suis sous linux donc ce code ne marche pas.

Bonsoir,

Quelques remarques dans l'ordre dans lequel je lis tes fichiers :

connexion.c
Code:

1 2 3 4 5 6 7: if(sock == SOCKET_INVALIDE) 8: { 9: printf("Socket invalide pour socket()\n"); 10: close(sock); 11: exit(1); 12: }
Refermer un socket qui n'existe pas n'a pas de sens (et peut provoquer un plantage);
Il te manque #include <stdlib.h> si tu veux utiliser exit().

Code:

25: erreur = connect(sock, (SOCKADDR *) &sin, sizeof(SOCKADDR));

C'est sizeof(SOCKADDR_IN), qu'il faut passer. C'est précisément parce que tu es obligé de transtyper toutes les structures dérivées vers SOCKADDR que la fonction te demande de passer leur taille : elle ne peut pas la déduire elle-même. Si tu mets celle de SOCKADDR, il n'y aucune raison pour qu'elle soit capable de lire correctement un SOCKADDR_IN.

D'une manière générale, si tu passes la taille du membre transmis plutôt que du type en général, sizeof(sin), tu es sûr de ne jamais te tromper, même si tu changes de type ;

Code:

36:void reception (SOCKET sock);

Ce prototype de fonction n'a aucune utilité à cet endroit. Typiquement, il devrait se trouver dans un *.h. Ensuite, ton fichier n'y fait pas appel. Enfin, déclarer cette fonction en fin de fichier n'a aucun intérêt ;

connexion.h

Code:

36:void reception (SOCKET sock);

(C'est un hasard que cela tomnbe à la même ligne). C'est déjà mieux, mais cela n'a toujours aucun intérêt. « reception() » est une fonction du serveur. Elle est donc complètement invisible au client.

mainconnexion.c

Code:

10 client = connexion(client,adress_ip);

Tu écrases ton socket avec la valeur de retour de ta fonction ! Bon, en l'occurrence, ça ne change rien puisque connexion() renvoie « sock » tel que reçu, mais cela reste une erreur de conception.
Code:

1 2 3 4 5 6 12: if(client == ERREUR_SOCKET || client == SOCKET_INVALIDE) 13: { 14: printf("Connexion impossible\n"); 15: }else{ 16: printf("Connexion réussie\n"); 17: }
Ta fonction connexion() renvoie le socket sans le modifier, ou bien tue le programme. Ce bloc de code ne sera donc jamais exécuté.

ServeurConnexion.c

Code:

8: sin.sin_addr.s_addr = htonl(INADDR_ANY);

Si je ne me trompe pas, les macros style INADDR_ANY sont faites pour remplir directement les champs de la structure. Il ne faut donc pas les convertir au préalable comme tu le fait, au risque de modifier leur valeur (bon. ici, INADDR_ANY correspond à 0.0.0.0, donc ça devrait fonctionner quand même).
Code:

1 2 3 4 5 6 7 8 9 10 11 12: if(erreur == ERREUR_SOCKET) 13: { 14: printf("Socket invalide pour bind()\n"); 15: close(sock); 16: } 17: erreur = listen (sock, 1); 18: if(erreur == ERREUR_SOCKET) 19: { 20: printf("Socket invalide pour listen()\n"); 21: close(sock); 22: }
En cas d'erreur, tu écris un message d'erreur et tu refermes ton socket mais tu n'interromps pas ton programme (ni avec return, ni avec exit()). Il n'y a donc aucun raison pour qu'il s'arrête seul. Il va donc passer à la suite et comme ton socket est toujours invalide, chaque étape va déclencher son propre message d'erreur. Voila pourquoi tu les obtiens tous.

25/03/2010, 02h32
guy_s

Merci de ta réponse !
j'ai fini par réussir à tout corriger tout seul finalement mais certaines de tes indications ont été précieuses...
encore merci.
25/03/2010, 12h32
Obsidian

Bravo, mais n'oublie pas :resolu:…