Socket - Envoi et réception de message

Bonjour à vous, j'essaye de faire un simple serveur/client, la connexion a l'air de se faire mais je galère un peu sur l'envoi et la réception du message, j'aimerais que quand le serveur voit un client se connecter il lui envoie un simple message de bienvenue. La question a déjà été posé mais malgré les différentes façons que j'ai essayé je n'y arrive pas du tout. Je n'arrive pas à rendre le client plus bavard afin de cibler le problème. Merci d'avoir pris le temps de lire et un double merci pour ceux qui essayeront de m'aider.

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
#include <iostream>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
int main()
{
    WSADATA WSAData;
    WSAStartup(MAKEWORD(2,0), &WSAData);
    SOCKET sock;
    SOCKADDR_IN sin;
    sin.sin_addr.s_addr	= inet_addr("127.0.0.1");
    sin.sin_family		= AF_INET;
    sin.sin_port		= htons(4148);
    sock = socket(AF_INET,SOCK_STREAM,0);
    std::string message = "Hello world";
    bind(sock, (SOCKADDR *)&sin, sizeof(sin));
 
    listen(sock, 0);
    int val = 0;
    while(1)
    {
        int sizeof_sin = sizeof(sin);
        val = accept(sock, (SOCKADDR *)&sin, &sizeof_sin);
        if(val != INVALID_SOCKET)
        {
            std::cout << "hello" << std::endl;
            send(sock, message.c_str(), sizeof(message.c_str()), 0);
        }
    }
 
 
    WSACleanup();
    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
#include <fstream>
#include <iostream>
#include <cstdio>
#include <winsock2.h>
#include <typeinfo>
#pragma comment(lib, "ws2_32.lib")
 
using namespace std;
int main()
{
    WSADATA WSAData;
    WSAStartup(MAKEWORD(2,0), &WSAData);
    SOCKET sock;
    SOCKADDR_IN sin;
    char buffer[2048];
    sin.sin_addr.s_addr	= inet_addr("127.0.0.1");
    sin.sin_family		= AF_INET;
    sin.sin_port		= htons(4148);
    sock = socket(AF_INET,SOCK_STREAM,0);
    bind(sock, (SOCKADDR *)&sin, sizeof(sin));
 
    connect(sock, (SOCKADDR *)&sin, sizeof(sin));
 
    int message_recu = recv(sock, buffer, sizeof(buffer), 0);
    cout << buffer << endl;
    string commande = (string)buffer;
    cout << commande << endl;
 
 
 
    WSACleanup();
    return 0;
}

Bonjour

Mauvaise rubrique. Ton code est du C++ et ici c'est la rubrique C

Ceci dit, voici un exemple basique client/serveur TCP en C pour système Unix/Linux
Le 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
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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
//
// Serveur réseau mode tcp
// Programme destiné à écouter un client via une connexion mode tcp
// Usage: prog [port]
//
 
#include <sys/types.h>						// Types prédéfinis "c"
#include <sys/socket.h>						// Généralités sockets
#include <sys/param.h>						// Paramètres et limites système
#include <netinet/in.h>						// Spécifications socket internet
#include <arpa/inet.h>						// Adresses format "arpanet"
#include <signal.h>							// Signaux de communication
#include <netdb.h>							// Gestion network database
#include <stdio.h>							// I/O fichiers classiques
#include <string.h>							// Gestion chaines de caractères
#include <stdlib.h>							// Librairie standard Unix
#include <unistd.h>							// Standards Unix
#include <errno.h>							// Erreurs système
#include "socket_tcp.h"						// Outils communs client et serveur
 
// Fonctions diverses
int init_socket(int);						// Initialisation socket
int client(t_socket*);						// Gestion client
int dialogue(int);							// Dialogue avec le client
int nslookup(struct sockaddr_in *, char*);	// Conversion adresse en nom
 
// Programme principal
int main(
	int argc,								// Nbre arguments
	char *argv[])							// Ptr arguments
{
	// Déclaration des variables
	char hostname[MAXHOSTNAMELEN + 1];		// Nom machine locale
	t_socket sock;							// Socket
 
	// Récuperation nom machine locale (juste pour l'exemple)
	if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
		fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, strerror(errno));
	printf("gethostname='%s'\n", hostname);
 
	// Détournement du signal émis à la mort du fils (il ne reste pas zombie)
	signal(SIGCHLD, SIG_IGN);
 
	// Initialisation socket
	if ((sock.sk_connect=init_socket(argc > 1 ?atoi(argv[1]) :0)) < 0) {
		fprintf(stderr, "ligne %u - init_socket() - %s\n", __LINE__, strerror(errno));
		exit(errno);
	}
	printf("Socket (%d) initialisée\n", sock.sk_connect);
 
	// Ecoute de la ligne
	if (listen(sock.sk_connect, 1) < 0) {
		fprintf(stderr, "ligne %u - listen() - %s\n", __LINE__, strerror(errno));
		return errno;
	}
	printf("Socket (%d) en écoute\n", sock.sk_connect);
 
	// Attente permanente
	fputc('\n', stdout);
	while (1) {
		printf("ppid=%u, pid=%u, socket=%d, attente entrée...\n", getppid(), getpid(), sock.sk_connect);
 
		// Attente connexion client
		if (client(&sock) < 0) {
			fprintf(stderr, "ligne %u - client() - %s\n", __LINE__, strerror(errno));
			continue;
		}
	}
	// Pas de sortie de programme - Boucle infinie
 
	// Fermeture socket et fin théorique du programme (pour être propre)
	close(sock.sk_connect);
	return 0;
}
 
// Initialisation socket
int init_socket(
	int port)								// Port (éventuel)
{
	// Déclaration des variables
	ushort i;								// Indice de boucle
	struct servent *service_info;			// Info. service demandé
	struct sockaddr_in adr_serveur;			// Adresse socket serveur
	int connect;							// Socket de connexion
 
	// Si le port n'est pas fourni
	if (port == 0) {
		// Récuperation port dans "/etc/services"
		if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) == NULL) {
			fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, strerror(errno));
			return -1;
		}
		port=ntohs(service_info->s_port);
		fputc('\n', stdout);
		printf("service_name='%s'\n", service_info->s_name);
		for (i=0; service_info->s_aliases[i] != NULL; i++)
			printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
		printf("service_port=%hu\n", ntohs(service_info->s_port));
		printf("service_protocole='%s'\n", service_info->s_proto);
	}
	else
		printf("port demandé=%hu\n", port);
 
	// Création socket
	if ((connect=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
		return -2;
	}
	printf("Socket créée (%d)\n", connect);
 
	// Remplissage adresse socket
	memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
	adr_serveur.sin_family=AF_INET;
	adr_serveur.sin_port=htons(port);
	adr_serveur.sin_addr.s_addr=INADDR_ANY;
 
	// Identification socket/réseau
	if (bind(connect, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in)) < 0) {
		fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, strerror(errno));
		return -3;
	}
	printf("Socket (%d) connectée au réseau\n", connect);
 
	// Renvoi socket créée
	return connect;
}
 
// Gestion du client
int client(
	t_socket *sock)							// Socket de communication
{
	// Déclaration des variables
	int pid;								// Process créé
 
	struct sockaddr_in adr_client;			// Adresse socket client
	socklen_t len_adr;						// Taille adresse
	char lookup[MAXHOSTNAMELEN + 1024 + 1];	// Correspondance adresse/nom
 
	// Attente connexion client
	len_adr=sizeof(struct sockaddr_in);
	if ((sock->sk_dialog=accept(sock->sk_connect, (struct sockaddr*)&adr_client, &len_adr)) < 0) {
		fprintf(stderr, "ligne %u - accept() - %s\n", __LINE__, strerror(errno));
		return -1;
	}
 
	// Client connecté
	if (nslookup(&adr_client, lookup) < 0)
		fprintf(stderr, "ligne %u - nslookup() - %s\n", __LINE__, strerror(errno));
	printf("ppid=%d, pid=%d, socket=(%d, %d) - Entrée émise, adr=%s\n", getppid(), getpid(), sock->sk_connect, sock->sk_dialog, lookup);
 
	// Duplication du process
	fflush(stdout);
	fflush(stderr);
	switch (pid=fork()) {
		case -1: // Erreur de fork
			close(sock->sk_connect);
			close(sock->sk_dialog);
			fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, strerror(errno)); 
			return -2;
 
		case 0: // Fils
			// Fermeture socket de connexion (inutilisée)
			close(sock->sk_connect);
 
			// Dialogue avec le client
			if (dialogue(sock->sk_dialog) < 0) {
				fprintf(stderr, "ligne %u - dialogue() - %s\n", __LINE__, strerror(errno));
				exit(errno);
			}
 
			// Fin du fils
			close(sock->sk_dialog);
			printf("\tppid=%d, pid=%d, socket=%d - Entrée raccrochée\n", getppid(), getpid(), sock->sk_dialog);
			exit(0);
 
		default: // Père
			close(sock->sk_dialog);
	}
 
	// Fin fonction
	return 0;
}
 
// Dialogue avec le client
int dialogue(
	int comm)								// Socket de communication
{
	// Déclaration des variables
	int sz_read;							// Nbre octets lus
 
	char buf[SZ_BUF];						// Buffer texte
	char *pt;								// Pointeur chaine
 
	// Lecture en boucle sur la socket
	while ((sz_read=read(comm, buf, SZ_BUF)) > 0) {
		// Le buffer reçu est transformé en chaine
		buf[sz_read]='\0';
 
		// Suppression du caractère '\n' éventuel
		if ((pt=strchr(buf, '\n')) != NULL) *pt='\0';
 
		// Mémorisation chaine contient "EOT" (optimisation)
		pt=strcmp(buf, "EOT") != 0 ?buf :NULL;
 
		// Affichage chaine reçue
		printf("\tppid=%u, pid=%u, socket=%d - Le serveur a lu %d [%s]%s\n", getppid(), getpid(), comm, sz_read, buf, pt != NULL ?"" :" => Fin de communication");
 
		// Si la chaine contient "EOT"
		if (pt == NULL) break;
	}
 
	// Si l'arrêt de la lecture est dû à une erreur
	if (sz_read < 0) {
		fprintf(stderr, "ligne %u - read() - %s\n", __LINE__, strerror(errno));
		return -1;
	}
 
	// Fin fonction
	printf("\tppid=%u, pid=%u, socket=%d - Client terminé\n", getppid(), getpid(), comm);
	return 0;
}
 
// Conversion adresse en nom
int nslookup(
	struct sockaddr_in *adr,				// Adresse à convertir
	char *lookup)							// Correspondance adresse/nom
{
	// Déclaration des variables
	char *adr_ascii;						// Adresse client mode ascii
	struct hostent *host_info;				// Informations host
 
	// Transformation adresse net en ascii
	if ((adr_ascii=inet_ntoa(adr->sin_addr)) == NULL) {
		fprintf(stderr, "ligne %u - inet_ntoa() - %s\n", __LINE__, strerror(errno));
		strcpy(lookup, "?");
		return -1;
	}
 
	// Récupération informations sur host par son adresse
	if ((host_info=gethostbyaddr(&adr->sin_addr.s_addr, sizeof(struct in_addr), AF_INET)) == NULL) {
		fprintf(stderr, "ligne %u - gethostbyaddr() - %s\n", __LINE__, strerror(errno));
		sprintf(lookup, "%s (?)", adr_ascii);
		return -2;
	}
	sprintf(lookup, "%s (%s)", adr_ascii, host_info->h_name);
	return 0;
}

Le 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
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
//
// Client réseau mode tcp
// Programme destiné à écrire des chaines dans une connexion mode tcp
// Usage: prog [nom serveur | adresse serveur [port]]
//
 
#include <sys/types.h>						// Types prédéfinis "c"
#include <sys/socket.h>						// Généralités sockets
#include <sys/param.h>						// Paramètres et limites système
#include <netinet/in.h>						// Spécifications socket internet
#include <stdio.h>							// I/O fichiers classiques
#include <string.h>							// Gestion chaines de caractères
#include <netdb.h>							// Gestion network database
#include <stdlib.h>							// Librairie standard Unix
#include <unistd.h>							// Standards Unix
#include <errno.h>							// Erreurs système
#include "socket_tcp.h"						// Outils communs client et serveur
 
#define SERVEUR_DEFAULT		("localhost")	// Nom serveur utilisé par défaut
 
typedef struct {
	char *host;								// Adresse serveur
	int port;								// Port serveur
} t_param;									// Type créé
 
// Fonctions diverses
int init_socket(t_socket*, t_param*);		// Initialisation socket
 
// Programme principal
int main(
	int argc,								// Nbre arg.
	char *argv[])							// Ptr arguments
{
	// Déclaration des variables
	t_socket sock;							// Socket
	t_param param;							// Paramètres de connexion
 
	char hostname[MAXHOSTNAMELEN + 1];		// Nom machine locale
	char buf[SZ_BUF];						// Buffer texte
	char *pt;								// Ptr de chaine
 
	// Récuperation nom machine locale (juste pour l'exemple)
	if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
		fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, strerror(errno));
	printf("gethostname='%s'\n", hostname);
 
	// Initialisation socket sur le serveur demandé en paramètre (ou le serveur par défaut)
	if (argc > 1) {
		param.host=argv[1];
		param.port=argc >2 ?atoi(argv[2]) :0;
	}
	else {
		param.host=SERVEUR_DEFAULT;
		param.port=0;
	}
	if (init_socket(&sock, &param) < 0) {
		fprintf(stderr, "ligne %u - init_socket(%s) - %s\n", __LINE__, param.host, strerror(errno));
		exit(errno);
	}
	printf("Initialisation socket (serveur=%s, port=%d, connexion=%d, dialogue=%d)\n", param.host, param.port, sock.sk_connect, sock.sk_dialog);
 
	// Saisie et envoi de la chaîne en boucle
	do {
		// Saisie de la chaîne
		fputs("Entrer chaine (EOT pour finir) :", stdout); fflush(stdout);
		fgets(buf, SZ_BUF, stdin);
 
		// Suppression du caractère '\n' éventuel
		if ((pt=strchr(buf, '\n')) != NULL) *pt='\0';
 
		// Envoi de la chaîne sur la socket
		if (write(sock.sk_dialog, buf, strlen(buf)) < 0)
			fprintf(stderr, "ligne %u - write(%s) - %s\n", __LINE__, buf, strerror(errno));
	} while (strcmp(buf, "EOT") != 0);
 
	// Fermeture socket et fin du programme
	close(sock.sk_dialog);
	return 0;
}
 
// Initialisation socket
int init_socket(
	t_socket *sock,							// Socket
	t_param *param)							// Paramètres de connexion
{
	// Déclaration des variables
	ushort i;								// Indice de boucle
	ushort j;								// Indice de boucle
 
	struct sockaddr_in adr_serveur;			// Adresse socket serveur
	struct hostent *host_info;				// Info. host
	struct servent *service_info;			// Info. service demandé
 
	// Récuperation informations serveur
	if ((host_info=gethostbyname(param->host)) == NULL) {
		fprintf(stderr, "ligne %u - gethostbyname(%s) - %s\n", __LINE__, param->host, strerror(errno));
		return -1;
	}
	fputc('\n', stdout);
	printf("host_info.h_name='%s'\n", host_info->h_name);
	for (i=0; host_info->h_aliases[i] != NULL; i++)
		printf("host_info.h_aliase[%hu]='%s'\n", i, host_info->h_aliases[i]);
	printf("host_info.h_addrtype=%u\n", host_info->h_addrtype);
	printf("host_info.h_length=%u\n", host_info->h_length);
	for (i=0; host_info->h_addr_list[i] != NULL; i++) {
		printf("host_info.h_addr_list[%hu]=", i);
		for (j=0; j < host_info->h_length; j++)
			printf("%hu ", (unsigned char)host_info->h_addr_list[i][j]);
		fputc('\n', stdout);
	}
 
	// Si le port n'est pas fourni
	if (param->port == 0) {
		// Récuperation port dans "/etc/services"
		if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) ==NULL) {
			fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, strerror(errno));
			return -2;
		}
		param->port=ntohs(service_info->s_port);
		fputc('\n', stdout);
		printf("service_name='%s'\n", service_info->s_name);
		for (i=0; service_info->s_aliases[i] != NULL; i++)
			printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
		printf("service_port=%hu\n", ntohs(service_info->s_port));
		printf("service_protocole='%s'\n", service_info->s_proto);
	}
	else
		printf("port demandé=%hu\n", param->port);
 
	// Remplissage adresse socket
	memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
	adr_serveur.sin_family=AF_INET;
	adr_serveur.sin_port=htons(param->port);
	memcpy(&adr_serveur.sin_addr.s_addr, host_info->h_addr, host_info->h_length);
 
	// Tentative de connexion en boucle permanente
	fputc('\n', stdout);
	do {
		// Création socket
		if ((sock->sk_dialog=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
			fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
			return -3;
		}
 
		// Connexion au serveur
		if ((sock->sk_connect=connect(sock->sk_dialog, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in))) < 0) {
			fprintf(stderr, "ligne %u - connect() - %s\n", __LINE__, strerror(errno));
			sleep(5);
		}
	} while (sock->sk_connect < 0);
	printf("Connexion réussie (connexion=%d, dialogue=%d)\n", sock->sk_connect, sock->sk_dialog);
 
	// Fin fonction
	return 0;
}

Et le fichier "socket_tcp.h"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//
// Header commun aux programmes de communication via tcp
//
 
#ifndef _SOCKET_TCP_H_
#define _SOCKET_TCP_H_
 
// Structure de travail socket
typedef struct {
	int sk_connect;							// Socket de connexion
	int sk_dialog;							// Socket de dialogue
} t_socket;									// Type créé
 
#define SERVICE_LABEL		("essai")		// Nom service requis
#define SERVICE_PROTOCOL	("tcp")			// Protocole service requis
#define SZ_BUF				(256)			// Taille buffer
 
#endif //_SOCKET_TCP_H_

Tu lances le serveur dans une première fenêtre. Soit en lui passant en paramètre le port à utiliser, soit en le laissant aller le chercher dans le fichier "/etc/services" (donc dans ce cas tu dois modifier ce fichier pour y inclure la ligne essai no_port/tcp).
Puis tu lances le client en lui passant en premier paramètre l'adresse du serveur (facultatif si c'est localhost et si pas besoin de n° de port) et en second paramètre le n° de port (facultatif si le fichier "/etc/services" a été alimenté)
Et ensuite, dans le client, tu tapes ce que tu veux (ce sera transmis au serveur qui l'affichera) et tu tapes "EOT" pour terminer.

Merci à toi pour la réponse, je comprends pas grand chose à ton code, il est bien compliqué pour un débutant. Je vais essayer de le comprendre mais c'est pas gagné, c'est vraiment un exemple basique ?

1 pièce(s) jointe(s)

En général, un débutant ne s'attaque pas aux sockets.
C'est un exemple basique pour quelqu'un qui connait le C et pour qui tout ce qui est pointeur ne pose aucun souci.

Voici le schéma auquel il se réfère
Pièce jointe 483898

Et ici un cours complet sur les sockets en C.

Salut,

Ceci dit, si tu travailles en C++, tu devrais te tourner vers boost.asio au lieu de t'amuser avec les socket plateforme-dependants.

Cette bibliothèque te permettrait de faire quelque chose de portable et te simplifierait énormément la vie ;)

En plus du très bon schéma de Sve@r
- tester les valeurs de retour n'est pas optionnel
- listen qui accepte 0 connexion me parait au mieux étrange...
- listen s'utilise par défaut avec SOMAXCONN
- recv reçoit jusqu'à X octets
- pour le reste, tu peux commencer par lire les ressources de ma signature

Je me souviens quand j'avais attaqué les sockets il y plus de 10 ans.... J'étais débutant, j'ai galéré comme un voleur et lu des tonnes de fois ce tuto : https://broux.developpez.com/articles/c/sockets/ J'ai fini par comprendre mais il ne faut pas s'attendre à quelque chose de simple avec les sockets* :aie:

* : en C :aie:

Merci à vous pour toutes ces ressources et info, je vais charbonner le truc et je compte bien y arriver, en tout cas j'ai de quoi lire. :D Sujet résolu !

Citation:

Envoyé par Bousk

En plus du très bon schéma de Sve@r

Et de son très bon exemple :applo:

Citation:

Envoyé par Bousk

listen qui accepte 0 connexion me parait au mieux étrange...

Aussi bizarrement que cela soit, ça fonctionne aussi avec mon exemple quand on met 0. Mais comme le man ne dit rien à ce propos, je penche pour un UB...

Citation:

Envoyé par Bktero

J'étais débutant, j'ai galéré comme un voleur

condamné aux galères bien sûr :aie: !!!

Citation:

Envoyé par Bktero

et lu des tonnes de fois ce tuto : https://broux.developpez.com/articles/c/sockets/

Je suis en train de le parcourir. C'est vrai qu'il n'est pas simple...

Citation:

Envoyé par Talsaj

Je vais essayer de le comprendre mais c'est pas gagné, c'est vraiment un exemple basique ?

L'astuce est très simple :mrgreen: Il ne faut pas voir cela comme une liste de fonctions (listen, bind, connect, ... dont certaines sont spécifiques au client et d'autres au serveur), mais comme des morceaux de code.

Le code client et le code serveur sont tout le temps les mêmes pour un datagramme donné, une connexion UDP, TCP, ... seul diverge l'envoi et la réception des données et où tu mets le code (dans un thread, dans une fonction, ...)

C'est pour cela :mrgreen: qu'il est important de lire les guides pour avoir les squelettes des différents codes source. Un guide comme celui ci Beej's Guide to Network Programming :zoubi: :zoubi: