Network Socket en C

Salut à tous.

Je commence à découvrir le langage C et je souhaite modifier le code de deux logiciels pour qu'ils puisse communiquer via un port.

j'ai découvert sur Wikipédia un code qui me parait vraiment trop simple pour que ça fonctionne :
Code:

1 2 3 4 Socket mysocket = getSocket(type = "TCP") connect(mysocket, address = "1.2.3.4", port = "80") send(mysocket, "Hello, world!") close(mysocket)
source (partie 6 exemple) : https://en.wikipedia.org/wiki/Network_socket#Example

J'ai essayé de le faire fonctionner sur l'ip 127.0.0.1 car les deux applications sont sur mon pc mais cela ne fonctionne pas.

Pensez-vous que ce code peut fonctionner ou c'est vraiment trop fantaisiste ?

Merci.

Bonjour,

Ce n'est pas simpliste, c'est juste que ce n'est pas en C.
D'autre part, je n'ai pas très bien compris ce que vous souhaitez faire.
Sinon, sous Windows, ce cours pourrait vous aider : https://melem.developpez.com/tutorie...ndows/winsock/

Merci beaucoup.

Savez-vous c'est qu'elle langage ?

J'étais persuadé que c'est du C.

La syntaxe ressemble à du Python, mais c'est possiblement du pseudo-code.

Bonjour

Citation:

Envoyé par card15nod2

J'ai essayé de le faire fonctionner sur l'ip 127.0.0.1 car les deux applications sont sur mon pc mais cela ne fonctionne pas.

Pensez-vous que ce code peut fonctionner ou c'est vraiment trop fantaisiste ?

Il n'est pas fantaisiste car il envoie "Hello" sur un serveur web (le port 80). Donc à priori le serveur (si la machine "1.2.3.4" possède un serveur web en écoute) devrait le recevoir et en ce sens, le code est déjà fonctionnel. Mais en aucune façon ce code ne te permettra de "dialoguer" avec ledit serveur car nulle part il ne lit ce que le serveur retourne.
Et effectivement ce n'est pas du C car le Cn'accepte pas d'appel de fonction avec paramètre nommé (port=80 par exemple).

Citation:

Envoyé par card15nod2

Je commence à découvrir le langage C

Ben... t'es pas sorti du sable.

A titre de TP, j'avais codé un "petit" exemple de client/serveur en C. Le serveur écoute en boucle infinie et chaque fois qu'un client arrive, il génère un fils chargé de répéter ce que le client lui dit (donc sans lui répondre).

Voici le code complet
socket_tcp.h

Code:

1
2
3
4
5
6
7
8
9
10
//
// Header commun aux programmes de communication via tcp
//
 
#ifndef _SOCKET_TCP_H_
#define _SOCKET_TCP_H_
 
#define SZ_BUF				(256)			// Taille buffer
 
#endif //_SOCKET_TCP_H_

Le client "client.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
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
//
// Client réseau mode tcp
// Programme destiné à écrire des chaines dans une connexion mode tcp
// Usage: prog port [nom serveur | adresse serveur]
//
 
#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 <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
	unsigned short port;					// Port serveur
} t_param;									// Type créé
 
// Fonctions diverses
int init_socket(t_param*);					// Initialisation socket
 
// Programme principal
int main(
	int argc,								// Nbre arg.
	char *argv[])							// Ptr arguments
{
	// Déclaration des variables
	int 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);
 
	// Si le port n'est pas fourni
	if (argc <= 1) {
		fprintf(stderr, "ligne %u - Pas de port\n", __LINE__);
		return -1;
	}
 
	// Initialisation socket sur le serveur demandé en paramètre (ou le serveur par défaut)
	param.port=atoi(argv[1]);
	if (argc > 2) {
		param.host=argv[2];
	}
	else {
		param.host=SERVEUR_DEFAULT;
	}
	if ((sock=init_socket(&param)) < 0) {
		fprintf(stderr, "ligne %u - init_socket(%s) - %s\n", __LINE__, param.host, strerror(errno));
		exit(errno);
	}
	printf("Initialisation socket (serveur=%s, port=%hu, socket=%d)\n", param.host, param.port, sock);
 
	// 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 (ne pas oublier le '\0')
		if (write(sock, buf, strlen(buf) + 1) < 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);
	return 0;
}
 
// Initialisation socket
int init_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
	int sock;								// Socket
 
	// 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);
	}
	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);
 
	// Création socket
	if ((sock=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
		return -3;
	}
	printf("Socket (%d) créée\n", sock);
 
	// Tentative de connexion en boucle permanente
	fputc('\n', stdout);
	while (1) {
		// Connexion au serveur
		if (connect(sock, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in)) == 0)
			break;
 
		fprintf(stderr, "ligne %u - connect() - %s\n", __LINE__, strerror(errno));
		sleep(5);
	}
	printf("Connexion réussie (socket=%d)\n", sock);
 
	// Fin fonction
	return sock;
}

Le serveur "serveur.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
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
//
// 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 <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
 
// Structure de travail socket
typedef struct {
	int sk_connect;							// Socket de connexion
	int sk_dialog;							// Socket de dialogue
} t_socket;									// Type créé
 
// Fonctions diverses
int init_socket(unsigned short);			// 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
 
	// Si le port n'est pas fourni
	if (argc <= 1) {
		fprintf(stderr, "ligne %u - Pas de port\n", __LINE__);
		return -1;
	}
 
 
	// 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 de connexion
	if ((sock.sk_connect=init_socket(argc > 1 ?atoi(argv[1]) :0)) < 0) {
		fprintf(stderr, "ligne %u - init_socket() - %s\n", __LINE__, strerror(errno));
		return errno;
	}
	printf("Socket de connexion (%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 de connexion (%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(
	unsigned short port)					// Port (éventuel)
{
	// Déclaration des variables
	struct sockaddr_in adr_serveur;			// Adresse socket serveur
	int sock;								// Socket de connexion
 
	// Création socket
	printf("port demandé=%hu\n", port);
	if ((sock=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, strerror(errno));
		return -2;
	}
	printf("Socket de connexion (%d) créée\n", sock);
 
	// 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(sock, (struct sockaddr*)&adr_serveur, sizeof(struct sockaddr_in)) < 0) {
		fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, strerror(errno));
		return -3;
	}
	printf("Socket de connexion (%d) identifiée sur le réseau\n", sock);
 
	// Renvoi socket créée
	return sock;
}
 
// 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 - Entrée émise (dialogue=%d, adr=%s)\n", getppid(), getpid(), sock->sk_connect, sock->sk_dialog, lookup);
 
	// Duplication du process (ne pas oublier de fflusher les flux standards)
	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 sock)								// 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(sock, buf, SZ_BUF)) > 0) {
		// Par précaution, 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(), sock, 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(), sock);
	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;
}

Tu peux les compiler (sous Linux). Ensuite d'un côté tu lances le serveur en lui donnant un numéro de port (ex ./serveur 5000) et de l'autre tu lances le client en lui mettant le même numéro de port. Et tu peux éventuellement rajouter le nom ou l'ip du serveur en second paramètre (ex ./client 5000 localhost) ce qui est utile si tu veux tester sur deux machines distinctes.

Ensuite le client te demande de saisir des lignes de texte et tout ce que tu tapes est affiché par le serveur.

Et leur équivalent en Python
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
#!/usr/bin/env python3
# coding: utf-8
 
import socket
import sys
 
class cSocket(object):
	def __init__(self, port, host="localhost"):
		self.__dialog=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		self.__dialog.connect((host, port))
		print("socket %s connectée avec %s sur le port %d" % (self.__dialog, host, port))
	# __init__()
 
	def dialogue(self):
		while True:
			msg=input("Tapez votre message (EOT pour quitter): ")
			self.__dialog.send(msg.encode("utf-8"))
			if msg == "EOT":
				print("Client teminé")
				break
			# if
		# while
	# dialogue()
# class cSocket
 
if __name__ == "__main__":
	sock=cSocket(int(sys.argv[1]), sys.argv[2] if len(sys.argv) > 2 else "localhost")
	sock.dialogue()
# if

Et 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
#!/usr/bin/env python3
# coding: utf-8
 
import socket
import sys
import os
 
class cSocket(object):
	def __init__(self, port):
		self.__connect=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		self.__connect.bind(("", port))
		self.__dialog=None
		print("socket %s prête à écouter sur le port %d" % (self.__connect, port))
	# __init__()
 
	# Ecoute
	def listen(self):
		self.__connect.listen(1)
		while True:
			(self.__dialog, infos)=self.__connect.accept()
			pid=os.fork()
			if pid == 0:
				self.__client(infos)
				exit(0)
			# if
		# while
	# listen()
 
	# Gestion du client connecté
	def __client(self, infos):
		try:
			host=socket.gethostbyaddr(infos[0])[0]
		except socket.herror as e:
			host="?"
		# try
		print(
			"client pid=%d - Entrée émise [adr=%s]" % (
				os.getpid(),
				host,
			)
		)
		data=None
		while data != "EOT":
			data=self.__dialog.recv(1024).decode("utf-8")
			print(
				"client pid=%d: Message: [%s]%s" % (
					os.getpid(),
					data,
					" => Arrêt du client" if data == "EOT" else "",
				)
			)
		# while
		print(
			"client pid=%d - Entrée raccrochée [adr=%s]" % (
				os.getpid(),
				host,
			)
		)
	# __client()
# class cSocket
 
if __name__ == "__main__":
	sock=cSocket(int(sys.argv[1]))
	sock.listen()
# if

Merci beaucoup.

C'est super impressionnant et passionnant.

Encore merci pour votre aide complète.

Je vais prendre le temps avec les bases, j'imaginais pouvoir sauter des chapitres et apprendre seulement ce dont j'ai besoin.

Petites questions supplémentaires si vous avez encore un peu de temps pour moi.

En fait, apprendre le langage C est une base super solide pour ensuite apprendre n'importe quel langage ? J'ai l'impression de voir du C de partout.

J'hésite beaucoup entre le C et Java. Je commence a survoler les deux langage, apprendre les deux en même temps c'est faire n'importe quoi ?

Je précise, que le choix du port n'est pas forcément du hasard :whistle:

1 certains nombre de logiciels utilisent des ports spécifiques. Voici la liste des ports logiciels, page wikipedia :zoubi:

Citation:

Envoyé par card15nod2

En fait, apprendre le langage C est une base super solide pour ensuite apprendre n'importe quel langage ? J'ai l'impression de voir du C de partout.

Étant donné que le monde du travail veut des développeurs qui empilent les briques logicielles, non par vraiment :aie:

Citation:

Envoyé par card15nod2

J'hésite beaucoup entre le C et Java. Je commence a survoler les deux langage, apprendre les deux en même temps c'est faire n'importe quoi ?

Oui c'est 1 peu n'importe quoi.
Selon moi, il faut apprendre 1 langage procédural pour l'aspect procédure/ fonction (comme le langage C) puis on peut passer à l'objet (d'abord objet pur comme le Java, puis au C++ est son objet/ générique et au Javascript pour son objet par prototypes) ou au fonctionnel (comme le langage Lisp)
Et il y a d'autres langages comme Prolog et SML pour les moteurs d'inférence, le génie logiciel, ...

Citation:

Oui c'est 1 peu n'importe quoi.
Selon moi, il faut apprendre 1 langage procédural pour l'aspect procédure/ fonction (comme le langage C) puis on peut passer à l'objet (d'abord objet pur comme le Java, puis au C++ est son objet/ générique et au Javascript pour son objet par prototypes) ou au fonctionnel (comme le langage Lisp)
Et il y a d'autres langages comme le Prolog et le SML/ Scheme pour les moteurs d'inférence, le génie logiciel, ...

Merci beaucoup, je vais rester sur le C pour le moment, en plus c'est le langage qui m'attire le plus.

Je voulais savoir également.

Si je veux ajouter un socket dans une fonction main déjà existante, comment ça se passe pour ne pas perturber le fonctionnement du programme ?