Socket windows/Linux

**yodaime** · 11/04/2006, 15h11

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

**Higestromm** · 11/04/2006, 15h30

Oui c'est possible.

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

**niglo** · 11/04/2006, 15h30

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

--- Serveur ---

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ;
}

**yodaime** · 11/04/2006, 15h36

Envoyé par niglo

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

Desoler j'ai oublier et c vrai que c plus clair

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

**yodaime** · 11/04/2006, 15h40

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

Je le remet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

**zul** · 11/04/2006, 15h56

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.

**Higestromm** · 11/04/2006, 16h21

A tout hazard vérifie si ta lecture est bien blocante !

**yodaime** · 11/04/2006, 16h33

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 !

Socket windows/Linux

C++

Discussions similaires

Partager

Partager