TP : Connexion serveur - client et envoi message

**leilald** · 30/11/2013, 22h57

Bonjour à tous, j'ai rencontrer un problème lors de l'exécution de mon programme qui établi la connexion entre un serveur et un client et qui envoie un message. je l'ai essayé en tp, mais au moment d'introduire la phrase y a erreur ! puis je vous transmettre le petit programme pour m'aider svp ? je n'arrive pas à le corriger

**patrice084** · 01/12/2013, 08h35

Le forum est là pour cela. Mettez en PJ votre document mais donnez aussi un peu plus de précision sur le TP que vous devez réaliser.

**leilald** · 01/12/2013, 18h47

Voici donc le petit programme en C. Je dois établir la connexion entre un serveur et un client en affichant le port et l'@ IP puis effectuer une communication en envoyant et recevant des messages entre les deux; une fois terminer on tape exit pour se déconnecter du serveur. Quand je l'exécute il n y a pas d'erreur, mais ne m'informe pas si la connexion est faite ! je dois taper la phrase à envoyer au serveur mais quand je le fais rien ne se passe, comme si il n'arrive pas à lire...
Votre aide me sera bien utile !

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
int main() {
 
    char phrase[255];
 
    struct sockaddr_in informations;
 
    informations.sin_family = AF_INET;
    informations.sin_port = htons(6666);
    informations.sin_addr.s_addr = inet_addr("127.0.0.1");
 
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
 
    if (socketID == -1) {
        perror("socket");
        exit (-1);
    }
 
 
 
    if ((connect(socketID, (struct sockaddr*) &informations, sizeof(struct sockaddr_in))) == -1) {
        perror("connect");
        exit (-1);
    }
 
 
    do {
 
    } while (strcmp(phrase, "EXIT") != 0);
 
 
 
    printf ("Entrez votre phrase : ");
    fgets(phrase, 255, stdin);
    phrase[strlen(phrase) - 1] = '\0';
 
 
    if ((send(socketID, phrase, strlen(phrase), 0)) == -1)
        perror("send");
 
 
 
 
    if (strcmp(phrase, "EXIT") != 0) {
        memset(phrase, 0, 255);
        recv(socketID, phrase, 255, 0);
        printf ("Phrase reçue : %s\n", phrase);
    }
 
 
 
    shutdown(socketID, SHUT_RDWR);
 
    return 0;
 
}

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
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
 
int main() {
 
    struct sockaddr_in information_server;
    struct sockaddr_in information_client;
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
    int connexion = 0;
 
 
    char phrase[255];
 
    socklen_t len = sizeof(struct sockaddr_in);
 
    if (socketID == -1) {
        perror("socket");
        exit(-1);
    }
 
    memset(&information_server, 0, sizeof(struct sockaddr_in));
    information_server.sin_port = htons(6666);
    information_server.sin_family = AF_INET;
 
    if ((bind(socketID, (struct sockaddr *) &information_server, sizeof(struct sockaddr))) == -1) {
        perror("bind");
        exit(-1);
    }
 
    if ((listen(socketID, 5)) == -1) {
        perror("listen");
        exit (-1);
    }
 
    memset(&information_client, 0, sizeof(struct sockaddr_in));
    connexion = accept(socketID, (struct sockaddr *) &information_client, &len);
 
 
 
    if (connexion == -1) {
        perror("accept");
        exit(-1);
    }
 
    printf ("Connexion acceptée de %s\n", inet_ntoa( information_client.sin_addr.s_addr ));
 
 
 
    do {
 
    } while (strcmp(phrase, "EXIT") != 0);
 
    memset(phrase, 0, 255);
    recv(connexion, phrase, 255, 0);
 
    if (strcmp(phrase, "EXIT") == 0) {
 
        printf ("Connexion fermée\n");
        shutdown(socketID, SHUT_RDWR);
        exit (0);
 
    }
 
    printf ("Phrase reçue : %s\n", phrase);
    printf ("Réponse : ");
    fgets(phrase, 255, stdin);
    phrase[strlen(phrase) - 1] = '\0';
 
    send(connexion, phrase, strlen(phrase), 0);
 
    return 0;
 
}

**bytecode** · 02/12/2013, 00h01

Salut

Je pense que cette exemple fait ce que tu demande..

bubsock.h

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
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
////////////////////////////////////////////////////////////////////////
//
//	Nom:		BubSock.h
//	Auteur:		BUILS Marc (Bub325)
//	E_Mail:		bub325@ifrance.com
//	Fonction:	Faciliter l'utilisation des sockets
//	Methode:	Creation de fonction simple
//
////////////////////////////////////////////////////////////////////////
 
#define SIZE_CHAINE 0xFFFF		// Taille des chaine de reception
 
// Utilise <winsock.h>
#ifndef _WINSOCKAPI_
	#include <winsock.h>
#endif
#pragma comment(lib, "wsock32.lib")
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKOPEN: 
//		Fonction d'initialisation et d'ouverture du socket
////////////////////////////////////////////////////////////////////////
 
#define BUBSOCK_OK		0	// La connection est faite
#define FALSE_WINSOCK	1	// Winsock ne s'est pas chargé
#define FALSE_HOST		2	// L'host n'est pas valide
#define FALSE_SOCKET	3	// La création du socket a échoué
#define FALSE_CONNECT	4	// La connection a échouée
#define FALSE_THREAD	5	// Le thread de reception n'a pas été créé
 
 
// Déclaration de la fonction de reception
DWORD WINAPI ClientRecv(LPVOID arg);
 
int sockopen(SOCKET* Client, char* host, int port)
{
    WSADATA WSAData;
    if (WSAStartup(MAKEWORD(2, 2), &WSAData)) {
		return FALSE_WINSOCK;
    }
	SOCKADDR_IN ClientSock;
	*Client = INVALID_SOCKET;
    HOSTENT* ServerInfos = NULL;
    if (!(ServerInfos = gethostbyname(host))) {
		WSACleanup();
		return FALSE_HOST;
    }
    memset(&ClientSock, 0, sizeof(SOCKADDR_IN));
    memcpy(&ClientSock.sin_addr.s_addr, ServerInfos->h_addr, ServerInfos->h_length);
    ClientSock.sin_port = htons(port);
    ClientSock.sin_family = AF_INET;
    if (!(*Client = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))) {
		WSACleanup();
		return FALSE_SOCKET;
    }
    if (connect(*Client, (SOCKADDR*) &ClientSock, sizeof(SOCKADDR_IN))) {
		WSACleanup();
		return FALSE_CONNECT;
    }
 
	// fonction de reception:
    DWORD RecvThreadID = 0;
	HANDLE RecvThread = NULL;
 
	if (!(RecvThread = CreateThread(NULL, 0, &ClientRecv, Client, 0, &RecvThreadID))) {
		WSACleanup();
		return FALSE_THREAD;
    }
    CloseHandle(RecvThread);
 
	return BUBSOCK_OK;
}
 
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKREAD: 
//		Fonction de reception des données
////////////////////////////////////////////////////////////////////////
 
//declaration de la fonction Recv
void SOCKREAD(SOCKET,char*);
void SOCKCLOSE(SOCKET);
 
DWORD WINAPI ClientRecv(LPVOID arg)
{
	char chaine[SIZE_CHAINE];
	int size_chaine = 0;
 
    SOCKET Client = *(SOCKET*) arg;
 
    while (recv(Client, &chaine[size_chaine++], 1, 0) > 0) 
	{
#ifdef USE_SOCKREAD
		if (chaine[size_chaine-1] == '\n') 
		{
			chaine[size_chaine] = '\0';
			SOCKREAD(Client,chaine);
			size_chaine = 0;
		}
#endif
	}
	WSACleanup();
 
#ifdef USE_SOCKCLOSE
	SOCKCLOSE(Client);
#endif
 
    return 0;
}
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKCLOSE: 
//		Fonction de fermeture de socket
////////////////////////////////////////////////////////////////////////
 
void sockclose(SOCKET Client)
{
	closesocket(Client);
}
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKWRITE: 
//		Fonction d'envoie de donnée
////////////////////////////////////////////////////////////////////////
 
void sockwrite(SOCKET Client,char* chaine)
{
	send(Client,chaine,strlen(chaine),NULL);
}
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKLISTEN: 
//		Fonction de mise en écoute d'un port
////////////////////////////////////////////////////////////////////////
 
#define FALSE_BIND		4	// Le bind du socket a échoué
#define FALSE_LISTEN	6	// La mise en écoute du port a échoué
 
// Déclaration de la fonction de reception
DWORD WINAPI ServListen(LPVOID arg);
 
int socklisten(SOCKET* Client, int port)
{
    WSADATA WSAData;
    if (WSAStartup(MAKEWORD(2, 2), &WSAData)) {
		return FALSE_WINSOCK;
    }
	SOCKADDR_IN ClientSock;
	*Client = INVALID_SOCKET;
 
	ClientSock.sin_addr.s_addr = INADDR_ANY;
    ClientSock.sin_port = htons(port);
    ClientSock.sin_family = AF_INET;
    if (!(*Client = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))) {
		WSACleanup();
		return FALSE_SOCKET;
    }
 
	//bind the socket
	if((bind(*Client, (LPSOCKADDR)&ClientSock, sizeof(ClientSock))) == SOCKET_ERROR)
	{
		WSACleanup();
		return FALSE_BIND;
	}
 
	//get socket to listen 
	if((listen(*Client, 2)) == SOCKET_ERROR)
	{
		WSACleanup();
		return FALSE_LISTEN;
	}
 
	// fonction de reception:
    DWORD RecvThreadID = 0;
	HANDLE RecvThread = NULL;
 
	if (!(RecvThread = CreateThread(NULL, 0, &ServListen, Client, 0, &RecvThreadID))) {
		WSACleanup();
		return FALSE_THREAD;
    }
    CloseHandle(RecvThread);
 
	return BUBSOCK_OK;
}
 
 
////////////////////////////////////////////////////////////////////////
//	SOCKLISTEN: 
//		Fonction de lecture du port
////////////////////////////////////////////////////////////////////////
 
//declaration de la fonction SOCKLISTEN
void SOCKLISTEN(SOCKET);
 
DWORD WINAPI ServListen(LPVOID arg)
{
    SOCKET Serv = *(SOCKET*) arg;
 
#ifdef USE_SOCKLISTEN
	SOCKET Client;
	while ((Client = accept(Serv, NULL, NULL)) > 0)
	{
		// fonction de reception:
		DWORD RecvThreadID = 0;
		HANDLE RecvThread = NULL;
 
		if (!(RecvThread = CreateThread(NULL, 0, &ClientRecv, &Client, 0, &RecvThreadID))) {
			WSACleanup();
			return FALSE_THREAD;
		}
		CloseHandle(RecvThread);
 
		SOCKLISTEN(Client);
	}
#endif
 
    return 0;
}

Le 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
41
42
43
44
45
46
47
#include <stdio.h>
 
#define USE_SOCKCLOSE
#define USE_SOCKREAD
#include "..\bubsock.h"
 
SOCKET Client;
 
void SOCKREAD(SOCKET _Client,char* chaine)
{
	printf("Serveur: %s",chaine);
}
 
void SOCKCLOSE(SOCKET _Client)
{
	printf("Le serveur a ete deconnecte\n");
	exit(0);
}
 
int main()
{
	if (sockopen(&Client,"127.0.0.1",23) != 0)
	{
		printf("Connexion impossible\n");
		exit(0);
	}
    printf("Vous etes connecte\n");
    while(1) 
	{
		char chaine[0xFF];
		int c = 0;
		do
		{
 
			chaine[c++] = getc(stdin);
			chaine[c] = '\0';
			if (!strcmp(chaine,"exit"))
			{
				sockclose(Client);
				exit(0);
			}
 
		} while (chaine[c-1] != '\n');
		sockwrite(Client,chaine);
    }
    return 0;
}

et le 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
#include <stdio.h>
 
#define USE_SOCKLISTEN
#define USE_SOCKCLOSE
#define USE_SOCKREAD
#include "..\bubsock.h"
 
SOCKET Client = INVALID_SOCKET;
SOCKET Serv;
 
void SOCKLISTEN(SOCKET _Client)
{
	if (Client == INVALID_SOCKET)
	{
		printf("Un client est arrivé\n");
		Client = _Client;
	}
	else sockclose(_Client);
}
 
void SOCKREAD(SOCKET _Client,char* chaine)
{
	printf("Client: %s",chaine);
}
 
void SOCKCLOSE(SOCKET _Client)
{
	if (_Client == Client)
	{
		printf("Le client s'est deconnecte\n");
		exit(0);
	}
}
 
int main(int argc, char* argv[])
{
	if (socklisten(&Serv,23) != 0)
	{
		printf("Connexion impossible du serveur.\n");
		exit(0);
	}
 
    printf("Serveur pret\n");
    while(1) 
	{
		char chaine[0xFF];
		int c = 0;
		do
		{
			chaine[c++] = getc(stdin);
			chaine[c] = '\0';
			if (!strcmp(chaine,"exit"))
			{
				if (Client != INVALID_SOCKET) sockclose(Client);
				exit(0);
			}
 
		} while (chaine[c-1] != '\n');
		if (Client != INVALID_SOCKET) sockwrite(Client,chaine);
    }
    return 0;
}

**bazoga** · 10/12/2013, 00h33

salam

C'est normal qu'il n'affiche rien car après connexion le client et le serveur rentrent tous les deux dans une boucle infinie :

Code :

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

1
2
3
do {
    // il faut mettre quelques choses :roll: afin que le test d’arrêt puisse   changé
} while (strcmp(phrase, "EXIT") != 0);

le tout est fait, il te reste juste une petite modification et ton code va fonctionner sans pb

Le code 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
int main() {
 
    char phrase[255];
 
    struct sockaddr_in informations;
 
    informations.sin_family = AF_INET;
    informations.sin_port = htons(6666);
    informations.sin_addr.s_addr = inet_addr("127.0.0.1");
 
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
 
    if (socketID == -1) {
        perror("socket");
        exit (-1);
    }
 
 
 
    if ((connect(socketID, (struct sockaddr*) &informations, sizeof(struct sockaddr_in))) == -1) {
        perror("connect");
        exit (-1);
    }
 
 
 
 
    for(;;){  // boucle infini
 
        printf ("Entrez votre phrase : ");
        fgets(phrase, 255, stdin);
        phrase[strlen(phrase) - 1] = '\0';
 
 
        if ((send(socketID, phrase, strlen(phrase)+1, 0)) == -1)
            perror("send");
 
        if (strcmp(phrase, "EXIT") != 0) {
            memset(phrase, 0, 255);
            recv(socketID, phrase, 255, 0);
            printf ("Phrase reçue : %s\n", phrase);
        } else
            break; // reception du mot EXIT => sortir de la boucle
 
    }
 
    shutdown(socketID, SHUT_RDWR);
    close(socketID);
 
    return 0;
 
}

le 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
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
 
int main() {
 
    struct sockaddr_in information_server;
    struct sockaddr_in information_client;
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
    int connexion = 0;
 
 
    char phrase[255];
 
    socklen_t len = sizeof(struct sockaddr_in);
 
    if (socketID == -1) {
        perror("socket");
        exit(-1);
    }
 
    memset(&information_server, 0, sizeof(struct sockaddr_in));
    information_server.sin_port = htons(6666);
    information_server.sin_family = AF_INET;
 
    if ((bind(socketID, (struct sockaddr *) &information_server, sizeof(struct sockaddr))) == -1) {
        perror("bind");
        exit(-1);
    }
 
    if ((listen(socketID, 5)) == -1) {
        perror("listen");
        exit (-1);
    }
 
    memset(&information_client, 0, sizeof(struct sockaddr_in));
    connexion = accept(socketID, (struct sockaddr *) &information_client, &len);
 
 
 
    if (connexion == -1) {
        perror("accept");
        exit(-1);
    }
 
    printf ("Connexion acceptée de %s\n", inet_ntoa( information_client.sin_addr.s_addr ));
 
    for(;;){
        memset(phrase, 0, 255);
        recv(connexion, phrase, 255, 0);
 
        if (strcmp(phrase, "EXIT") == 0) {
 
            printf ("Connexion fermée\n");
            shutdown(connexion, SHUT_RDWR); // c'est la socket de transmission qu'il faut utiliser et non plus socketID !!
            close(connexion);
            close(socketID);
            break;
        }
 
        printf ("Phrase reçue : %s\n", phrase);
        printf ("Réponse : ");
        fgets(phrase, 255, stdin);
        phrase[strlen(phrase) - 1] = '\0';
 
        send(connexion, phrase, strlen(phrase), 0);
    }
 
    return 0;
 
}

j'espère que ceci va t'aider
E.BAZoga

**leilald** · 13/12/2013, 21h43

J'ai lu et relus sans remarquer ça ! Je devais être saturée

Merci à vous

TP : Connexion serveur - client et envoi message

Réseau C

Discussions similaires

Partager

Partager