Socket windows/Linux

Version imprimable

Bonjour !

Voila mon problème. Je réalise un petit programme avec de sockets.
Je doit creer un serveur sous windows et un client sous linux.
Tout d'abord est ce que c'est possible ?

Je pense que oui mais je n'en suis pas sur.
J'ai codé un serveur et un client. Le client doit recevoir un caractère du serveur. Aparament le serveur detecte la connexion mais le client n'affiche pas le resultat souhaiter a savoir le caractère recu.

Pour information je code avec Microsoft visual c++ 6 sous windows xp sp2 et avec eclipse sous madrake 10.1.

Je vous fournit mon code :

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
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
 
#include <io.h>
#include <stdio.h>
 
int main( void )
{
	WSADATA WSAData ;
	WSAStartup(MAKEWORD(2,0), &WSAData);
 
	int sockfd_serveur, sockfd_client ;
	int long_serveur, long_client ;
	struct sockaddr_in adresse_serveur ;
	struct sockaddr_in adresse_client ;
 
	sockfd_serveur = socket( AF_INET, SOCK_STREAM, 0) ;
 
	adresse_serveur.sin_family = AF_INET ;
	adresse_serveur.sin_addr.s_addr = htonl(INADDR_ANY) ;
	adresse_serveur.sin_port = htons(9734) ;
	long_serveur = sizeof( adresse_serveur ) ;
	bind( sockfd_serveur, (struct sockaddr *)&adresse_serveur, long_serveur) ;
 
	listen(sockfd_serveur, 5) ;
	while(1)
	{
		char ch ;
 
		printf("serveur en attente\n") ;
 
		long_client = sizeof( adresse_client ) ;
		sockfd_client = accept(sockfd_serveur, (struct sockaddr *)&adresse_client, &long_client) ;
 
		_read(sockfd_client, &ch, 1) ;
		ch++ ;
		_write(sockfd_client, &ch, 1) ;
		_close(sockfd_client) ;
	}
 
	return 0 ;
 }
 
Client-----------------------------------------
 
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
 
#include <io.h>
#include <stdio.h>
 
int main( void )
{
	WSADATA WSAData;
	WSAStartup(MAKEWORD(2,0), &WSAData);
 
	int sockfd ;
	int longeur ;
	struct sockaddr_in adresse ;
	int resultat ;
	char ch = 'A' ;
 
	sockfd = socket(AF_INET, SOCK_STREAM, 0) ;
 
	adresse.sin_family = AF_INET ;
	adresse.sin_addr.s_addr = inet_addr("127.0.0.1") ;
	adresse.sin_port = 9734 ;
	longeur = sizeof( adresse ) ;
 
	resultat = connect(sockfd, (struct sockaddr *)&adresse, longeur) ;
 
	if( resultat == -1 )
	{
		perror("oops : client1") ;
		exit(1) ;
	}
 
	_write(sockfd, &ch, 1) ;
	_read(sockfd, &ch, 1) ;
	printf("caractere provenant du serveur = %c\n", ch) ;
	_close( sockfd ) ;
	exit(0) ;
	return 0 ;
}

J'espère que sa vous aidera a y voir plus clair !
Merci d'avance

[Balises code rajoutées par Fiquet, merci d'y penser la prochaine fois]

11/04/2006, 15h30
Higestromm

Oui c'est possible.

Cependant j'ai l'impression que tu as coder ton client sous windows également non ?

Re: Socket windows/Linux

Citation:

Envoyé par yodaime

Voila mon problème. Je réalise un petit programme avec de sockets.
Je doit creer un serveur sous windows et un client sous linux.
Tout d'abord est ce que c'est possible ?

OUI bien entendu et fort heureusement !!

Pense aux balises code la prochaine fois ca donne un code lisible :wink:

--- 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
 
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
 
#include <io.h>
#include <stdio.h>
 
int main( void )
{
	WSADATA WSAData ;
	WSAStartup(MAKEWORD(2,0), &WSAData);
 
	int sockfd_serveur, sockfd_client ;
	int long_serveur, long_client ;
	struct sockaddr_in adresse_serveur ;
	struct sockaddr_in adresse_client ;
 
	sockfd_serveur = socket( AF_INET, SOCK_STREAM, 0) ;
 
	adresse_serveur.sin_family = AF_INET ;
	adresse_serveur.sin_addr.s_addr = htonl(INADDR_ANY) ;
	adresse_serveur.sin_port = htons(9734) ;
	long_serveur = sizeof( adresse_serveur ) ;
	bind( sockfd_serveur, (struct sockaddr *)&adresse_serveur, long_serveur) ;
 
	listen(sockfd_serveur, 5) ;
	while(1)
	{
		char ch ;
 
		printf("serveur en attente\n") ;
 
		long_client = sizeof( adresse_client ) ;
		sockfd_client = accept(sockfd_serveur, (struct sockaddr *)&adresse_client, &long_client) ;
 
		_read(sockfd_client, &ch, 1) ;
		ch++ ;
		_write(sockfd_client, &ch, 1) ;
		_close(sockfd_client) ;
	}
 
	return 0 ;
 }

--- 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
 
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
 
#include <io.h>
#include <stdio.h>
 
int main( void )
{
	WSADATA WSAData;
	WSAStartup(MAKEWORD(2,0), &WSAData);
 
	int sockfd ;
	int longeur ;
	struct sockaddr_in adresse ;
	int resultat ;
	char ch = 'A' ;
 
	sockfd = socket(AF_INET, SOCK_STREAM, 0) ;
 
	adresse.sin_family = AF_INET ;
	adresse.sin_addr.s_addr = inet_addr("127.0.0.1") ;
	adresse.sin_port = 9734 ;
	longeur = sizeof( adresse ) ;
 
	resultat = connect(sockfd, (struct sockaddr *)&adresse, longeur) ;
 
	if( resultat == -1 )
	{
		perror("oops : client1") ;
		exit(1) ;
	}
 
	_write(sockfd, &ch, 1) ;
	_read(sockfd, &ch, 1) ;
	printf("caractere provenant du serveur = %c\n", ch) ;
	_close( sockfd ) ;
	exit(0) ;
	return 0 ;
}

11/04/2006, 15h36
yodaime

Re: Socket windows/Linux

Citation:

Envoyé par niglo

Pense aux balises code la prochaine fois ca donne un code lisible :wink:

Desoler j'ai oublier et c vrai que c plus clair :oops:
Je suis rassurer que cela soit possible. Mais d'après vous qu'est ce qui ne vas pas dans mon code ?

J'ai beau me creuser je ne voi pas

Desoler je vient de me rendre compte que j'avais pas mis le bon code pour mon client

Je le remet :

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
 
#include <sys/types.h> 
#include <sys/socket.h>
#include <stdio.h>
 
#include <netinet/in.h>
#include <arpa/inet.h>
 
#include <sys/un.h>
#include <unistd.h>
 
int main()
{
	int sockfd ;
	int longeur ;
	struct sockaddr_in adresse ;
	int resultat ;
	char ch = 'A' ;
 
	sockfd = socket(AF_INET, SOCK_STREAM, 0) ;
 
	adresse.sin_family = AF_INET ;
	adresse.sin_addr.s_addr = inet_addr("10.13.80.4") ;
	adresse.sin_port = htons(9734) ;
	longeur = sizeof( adresse ) ;
 
	resultat = connect(sockfd, (struct sockaddr *)&adresse, longeur) ;
 
	if( resultat == -1 )
	{
		perror("oops : client1") ;
		exit(1) ;
	}
 
	write(sockfd, &ch, 1) ;
	read(sockfd, &ch, 1) ;
	printf("caractere proveneant du serveur = %c\n", ch) ;
	close( sockfd ) ;
	exit(0) ;
}

Voila c'est mieux comme sa !

11/04/2006, 15h56
zul

Essaye de commencer par tester ton serveur seulement en utilisant comme client telnet.
Tu pourra ensuite tester ton client.
Difficile de débugger deux choses qui communiquent en même temps.
11/04/2006, 16h21
Higestromm

A tout hazard vérifie si ta lecture est bien blocante !
11/04/2006, 16h33
yodaime

C bon !

En fait j'ai fait l'inverse c'est a dire client windows et serveur linux et sa marche.
Mon problème n'est pas vraiment résolu mais sa me va comme sa donc tout est pour le mieux

Merci a tous pour votre aide !