Browse Source

Importation du code depuis GitHub

gasc 2 months ago
commit
fca1caf5ea
4 changed files with 1043 additions and 0 deletions
  1. 3
    0
      README.md
  2. 274
    0
      tsock_v1_gasc_m.c
  3. 379
    0
      tsock_v2_gasc_m.c
  4. 387
    0
      tsock_v3_gasc_m.c

+ 3
- 0
README.md View File

@@ -0,0 +1,3 @@
1
+# Tsocks (Computer science lab)
2
+Here I share my own implementation of [Tsocks](http://tsocks.sourceforge.net/) in C carried out as part of the computer science work at INSA Toulouse.
3
+

+ 274
- 0
tsock_v1_gasc_m.c View File

@@ -0,0 +1,274 @@
1
+/* librairie standard ... */
2
+#include <stdlib.h>
3
+/* pour getopt */
4
+#include <unistd.h>
5
+/* déclaration des types de base */
6
+#include <sys/types.h>
7
+/* constantes relatives aux domaines, types et protocoles */
8
+#include <sys/socket.h>
9
+/* constantes et structures propres au domaine UNIX */
10
+#include <sys/un.h>
11
+/* constantes et structures propres au domaine INTERNET */
12
+#include <netinet/in.h>
13
+/* structures retournées par les fonctions de gestion de la base de
14
+données du réseau */
15
+#include <netdb.h>
16
+/* pour les entrées/sorties */
17
+#include <stdio.h>
18
+/* pour la gestion des erreurs */
19
+#include <errno.h>
20
+
21
+/* 
22
+	TP AIPS
23
+	Version 1 - Fonctionnelle
24
+*/
25
+
26
+///////////////////////////////////////////////////////////
27
+
28
+// Fonctions d'erreurs
29
+/// Afficher l'usage et quitte
30
+void err_args() {
31
+	printf("[!] Usage: cmd [-u][-p|-s][-n ##][-l ##]\n");
32
+	exit(EXIT_FAILURE);
33
+}
34
+
35
+/// Affiche erreur socket
36
+void err_socks(){
37
+	printf("\n[-] Erreur lors de la création/affectation du socket");
38
+}
39
+
40
+/// Affiche erreur connexion
41
+void err_conn(){
42
+	printf("\n[-] Erreur lors de la connexion serveur/client");
43
+}
44
+
45
+///////////////////////////////////////////////////////////
46
+
47
+
48
+// Given functions
49
+void construire_message(char *message, char motif, int lg) {
50
+	int i;
51
+	for (i=0;i<lg;i++) message[i] = motif;
52
+}
53
+
54
+void afficher_message(char *message, int lg) {
55
+	int i;
56
+	printf("[+] Message construit : ");
57
+	for (i=0;i<lg;i++) printf("%c", message[i]); 
58
+	printf("\n");
59
+}
60
+
61
+///////////////////////////UDP/////////////////////////////
62
+
63
+int source_UDP(char *HOSTNAME, int PORT, int nb_message, int l_msg) {
64
+	// Création du socket UDP
65
+	printf("[+] Création du socket local...");
66
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
67
+
68
+	if (s_udp == -1){
69
+		err_socks();
70
+		return 1;
71
+	} else printf("Ok!\n");
72
+
73
+
74
+	// Création du socket distant
75
+	printf("[+] Création du socket distant...");
76
+	struct sockaddr_in servaddr;
77
+	memset(&servaddr, 0, sizeof(servaddr));
78
+	struct hostent *hp ;
79
+
80
+	// Résolution du nom
81
+	if ((hp = gethostbyname(HOSTNAME)) == NULL) {
82
+		err_conn();
83
+		return 1;
84
+	}
85
+
86
+	// Creation de la struct du socket distant 
87
+	servaddr.sin_family = AF_INET;
88
+	memcpy((char*)&(servaddr.sin_addr.s_addr), hp->h_addr, hp->h_length);
89
+	servaddr.sin_port = PORT;
90
+	printf("Ok!\n");
91
+
92
+	printf("[+] Envoi des messages à %s:%d...\n", HOSTNAME, PORT);
93
+
94
+	// TEST
95
+	char *pmesg = malloc(l_msg*sizeof(char));
96
+	char c = 'a';
97
+
98
+	// Création des messages à envoyer et envoi
99
+	for (int i = 1; i <= nb_message; i++){
100
+		construire_message(pmesg, c, l_msg);
101
+		afficher_message(pmesg, l_msg);
102
+		sendto(s_udp, 
103
+			pmesg, 
104
+			strlen(pmesg), 
105
+			0, 
106
+			(const struct sockaddr *) &servaddr, 
107
+			sizeof(servaddr)
108
+		);
109
+		c++;
110
+	}
111
+
112
+	return 0;
113
+}
114
+
115
+int puit_UDP(int PORT, int nb_message, int l_msg) {
116
+	// Création du socket UDP
117
+	printf("[+] Création du socket local...");
118
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
119
+
120
+	if (s_udp == -1){
121
+		err_socks();
122
+		return 1;
123
+	} else printf("Ok!\n");
124
+
125
+	struct sockaddr_in servaddr, cliaddr;
126
+	memset(&servaddr, 0, sizeof(servaddr)); 
127
+    memset(&cliaddr, 0, sizeof(cliaddr));
128
+	
129
+	servaddr.sin_family = AF_INET;
130
+    servaddr.sin_addr.s_addr = INADDR_ANY; 
131
+    servaddr.sin_port = PORT; 
132
+
133
+	if ( bind(s_udp, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0 ) { 
134
+        err_socks();
135
+		return 1;
136
+    }
137
+	printf("[+] Bind ok !\n");
138
+
139
+	int n;
140
+	int len;
141
+	int msg_count = 0;
142
+	char buffer[l_msg];
143
+
144
+	printf("[+] Waiting for messages...\n");
145
+	
146
+	while (msg_count >= nb_message || nb_message != -1){
147
+		n = recvfrom(s_udp, (char *)buffer, l_msg,
148
+                MSG_WAITALL, (struct sockaddr *) &cliaddr, 
149
+                &len);
150
+		buffer[n] = '\0';
151
+		printf("[>] Reception du message n°%d : %s\n", msg_count, buffer);
152
+
153
+		n = 0;
154
+		msg_count++;
155
+	}
156
+     
157
+
158
+
159
+	return 0;
160
+}
161
+
162
+////////////////////////////TCP/////////////////////////////
163
+
164
+int source_TCP(char *HOSTNAME, int PORT, int nb_message, int l_msg){
165
+
166
+	return 1;
167
+}
168
+
169
+int puit_TCP(int PORT, int nb_message, int l_msg){
170
+	
171
+	return 1;
172
+}
173
+
174
+///////////////////////////////////////////////////////////
175
+
176
+/// Main entry
177
+int main (int argc, char **argv)
178
+{	
179
+	int c;
180
+	extern char *optarg;
181
+	extern int optind;
182
+	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
183
+	int source = -1; /* 0 = puits, 1 = source */
184
+	int tcp = 1; /* 0 = UDP, 1 = TCP */
185
+	int l_msg = 30; /* longueur du message, en octet. Defaut : 30. */
186
+
187
+	while ((c = getopt(argc, argv, "pn:sul:")) != -1) {
188
+		switch (c) {
189
+		case 'p':
190
+			if (source == 1) {
191
+				err_args();
192
+			}
193
+			source = 0;
194
+			break;
195
+
196
+		case 's':
197
+			if (source == 0) {
198
+				err_args();
199
+			}
200
+			source = 1;
201
+			break;
202
+
203
+		case 'n':
204
+			nb_message = atoi(optarg);
205
+			break;
206
+
207
+		case 'u':
208
+			tcp = 0;
209
+			break;
210
+
211
+		case 'l':
212
+			l_msg = atoi(optarg);
213
+		
214
+		default:
215
+			err_args();
216
+			break;
217
+		}
218
+	}
219
+
220
+	int PORT = atoi(argv[argc-1]);
221
+	//PORT = htons(PORT);
222
+
223
+	if (source == -1) {
224
+		err_args();
225
+	}
226
+
227
+	if (tcp)
228
+		printf("[+] On utilise le protocol TCP\n");
229
+	else 
230
+		printf("[+] On utilise le protocol UDP\n");
231
+	
232
+
233
+	char* HOSTNAME = "";
234
+	if (source == 1){
235
+		printf("[+] On est dans la source\n");
236
+		HOSTNAME = argv[argc-2];
237
+	}
238
+	else
239
+		printf("[+] On est dans le puit\n");
240
+
241
+	if (nb_message != -1) {
242
+		if (source == 1)
243
+			printf("[+] Nombre de tampons à envoyer : %d\n", nb_message);
244
+		else
245
+			printf("[+] Nombre de tampons à recevoir : %d\n", nb_message);
246
+	} else {
247
+		if (source == 1) {
248
+			nb_message = 10 ;
249
+			printf("[~] Nombre de tampons à envoyer = 10 par défaut\n");
250
+		} 
251
+		else
252
+			printf("[+] Nombre de tampons à envoyer = infini\n");
253
+	}
254
+
255
+	if (l_msg == 30) 
256
+		printf("[~] Longueur des messages à envoyer/recevoir : 30 par défaut\n");
257
+	else
258
+		printf("[+] Nombre de tampons à envoyer/recevoir : %d \n", l_msg);
259
+
260
+	int s = 1;
261
+
262
+	// Choose the right function
263
+	if (tcp){
264
+		if (source) s = source_TCP(HOSTNAME, PORT, nb_message, l_msg);
265
+		else s = puit_TCP(PORT, nb_message, l_msg);
266
+	}
267
+	else {
268
+		if (source) s = source_UDP(HOSTNAME, PORT, nb_message, l_msg);
269
+		else s = puit_UDP(PORT, nb_message, l_msg);
270
+	}
271
+
272
+	return s;
273
+}
274
+

+ 379
- 0
tsock_v2_gasc_m.c View File

@@ -0,0 +1,379 @@
1
+/* librairie standard ... */
2
+#include <stdlib.h>
3
+/* pour getopt */
4
+#include <unistd.h>
5
+/* déclaration des types de base */
6
+#include <sys/types.h>
7
+/* constantes relatives aux domaines, types et protocoles */
8
+#include <sys/socket.h>
9
+/* constantes et structures propres au domaine UNIX */
10
+#include <sys/un.h>
11
+/* constantes et structures propres au domaine INTERNET */
12
+#include <netinet/in.h>
13
+/* structures retournées par les fonctions de gestion de la base de
14
+données du réseau */
15
+#include <netdb.h>
16
+/* pour les entrées/sorties */
17
+#include <stdio.h>
18
+/* pour la gestion des erreurs */
19
+#include <errno.h>
20
+
21
+/* 
22
+	TP AIPS
23
+	Version 2 - FONCTIONNELLE 
24
+*/
25
+
26
+///////////////////////////////////////////////////////////
27
+
28
+// Fonctions d'erreurs
29
+/// Afficher l'usage et quitte
30
+void err_args() {
31
+	printf("[!] Usage: cmd [-u][-p|-s][-n ##][-l ##]\n");
32
+	exit(EXIT_FAILURE);
33
+}
34
+
35
+/// Affiche erreur socket
36
+void err_socks(){
37
+	printf("\n[-] Erreur lors de la création/affectation du socket\n");
38
+}
39
+
40
+/// Affiche erreur connexion
41
+void err_conn(){
42
+	printf("\n[-] Erreur lors de la connexion serveur/client\n");
43
+}
44
+
45
+///////////////////////////////////////////////////////////
46
+
47
+
48
+// Given functions
49
+void construire_message(char *message, char motif, int lg) {
50
+	int i;
51
+	for (i=0;i<lg;i++) message[i] = motif;
52
+}
53
+
54
+void afficher_message(char *message, int lg) {
55
+	int i;
56
+	printf("[+] Message construit : ");
57
+	for (i=0;i<lg;i++) printf("%c", message[i]); 
58
+	printf("\n");
59
+}
60
+
61
+///////////////////////////UDP/////////////////////////////
62
+
63
+int source_UDP(char *HOSTNAME, int PORT, int nb_message, int l_msg) {
64
+	// Création du socket UDP
65
+	printf("[+] Création du socket local...");
66
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
67
+
68
+	if (s_udp == -1){
69
+		err_socks();
70
+		return 1;
71
+	} else printf("Ok!\n");
72
+
73
+
74
+	// Création du socket distant
75
+	printf("[+] Création du socket distant...");
76
+	struct sockaddr_in servaddr;
77
+	memset(&servaddr, 0, sizeof(servaddr));
78
+	struct hostent *hp ;
79
+
80
+	// Résolution du nom
81
+	if ((hp = gethostbyname(HOSTNAME)) == NULL) {
82
+		err_conn();
83
+		return 1;
84
+	}
85
+
86
+	// Creation de la struct du socket distant 
87
+	servaddr.sin_family = AF_INET;
88
+	memcpy((char*)&(servaddr.sin_addr.s_addr), hp->h_addr, hp->h_length);
89
+	servaddr.sin_port = PORT;
90
+	printf("Ok!\n");
91
+
92
+	printf("[+] Envoi des messages à %s:%d...\n", HOSTNAME, PORT);
93
+
94
+	// TEST
95
+	char *pmesg = malloc(l_msg*sizeof(char));
96
+	char c = 'a';
97
+
98
+	// Création des messages à envoyer et envoi
99
+	for (int i = 1; i <= nb_message; i++){
100
+		construire_message(pmesg, c, l_msg);
101
+		afficher_message(pmesg, l_msg);
102
+		sendto(s_udp, 
103
+			pmesg, 
104
+			strlen(pmesg), 
105
+			0, 
106
+			(const struct sockaddr *) &servaddr, 
107
+			sizeof(servaddr)
108
+		);
109
+		c++;
110
+		if (c >= '{') c = 'a';
111
+	}
112
+
113
+	return 0;
114
+}
115
+
116
+int puit_UDP(int PORT, int nb_message, int l_msg) {
117
+	// Création du socket UDP
118
+	printf("[+] Création du socket local...");
119
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
120
+
121
+	if (s_udp == -1){
122
+		err_socks();
123
+		return 1;
124
+	} else printf("Ok!\n");
125
+
126
+	struct sockaddr_in servaddr, cliaddr;
127
+	memset(&servaddr, 0, sizeof(servaddr)); 
128
+    memset(&cliaddr, 0, sizeof(cliaddr));
129
+	
130
+	servaddr.sin_family = AF_INET;
131
+    servaddr.sin_addr.s_addr = INADDR_ANY; 
132
+    servaddr.sin_port = PORT; 
133
+
134
+	if ( bind(s_udp, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0 ) { 
135
+        err_socks();
136
+		return 1;
137
+    }
138
+	printf("[+] Bind ok !\n");
139
+
140
+	int n;
141
+	int len;
142
+	int msg_count = 0;
143
+	char buffer[l_msg];
144
+
145
+	printf("[+] Waiting for messages...\n");
146
+	
147
+	while (msg_count >= nb_message || nb_message != -1){
148
+		n = recvfrom(s_udp, (char *)buffer, l_msg,
149
+                MSG_WAITALL, (struct sockaddr *) &cliaddr, 
150
+                &len);
151
+		buffer[n] = '\0';
152
+		printf("[>] Reception du message n°%d : %s\n", msg_count, buffer);
153
+
154
+		n = 0;
155
+		msg_count++;
156
+	}
157
+
158
+	return 0;
159
+}
160
+
161
+////////////////////////////TCP/////////////////////////////
162
+
163
+int source_TCP(char *HOSTNAME, int PORT, int nb_message, int l_msg){
164
+	// Création du socket TCP
165
+	printf("[+] Création du socket local...");
166
+	int s_tcp = socket(AF_INET,SOCK_STREAM, 0);
167
+
168
+	if (s_tcp == -1){
169
+		err_socks();
170
+		return 1;
171
+	} else printf("Ok!\n");
172
+
173
+	// Création du socket distant
174
+	printf("[+] Création du socket distant...");
175
+	struct sockaddr_in servaddr;
176
+	memset(&servaddr, 0, sizeof(servaddr));
177
+	struct hostent *hp ;
178
+
179
+	// Résolution du nom
180
+	if ((hp = gethostbyname(HOSTNAME)) == NULL) {
181
+		err_conn();
182
+		return 1;
183
+	}
184
+
185
+	// Creation de la struct du socket distant 
186
+	servaddr.sin_family = AF_INET;
187
+	memcpy((char*)&(servaddr.sin_addr.s_addr), hp->h_addr, hp->h_length);
188
+	servaddr.sin_port = PORT;
189
+	printf("Ok!\n");
190
+
191
+	if (connect(s_tcp, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0){
192
+		err_conn();
193
+		return 1;
194
+	}
195
+
196
+
197
+	printf("[+] Envoi des messages...\n");
198
+
199
+	// TEST
200
+	char *pmesg = malloc(l_msg*sizeof(char));
201
+	char c = 'a';
202
+
203
+	// Création des messages à envoyer et envoi
204
+	for (int i = 1; i <= nb_message; i++){
205
+		construire_message(pmesg, c, l_msg);
206
+		afficher_message(pmesg, l_msg);
207
+		if (write(s_tcp, pmesg, l_msg) < 0){
208
+			err_conn();
209
+			return 1;
210
+		}
211
+		c++;
212
+		if (c >= '{') c = 'a';
213
+	}
214
+
215
+	close(s_tcp);
216
+
217
+	return 0;
218
+}
219
+
220
+int puit_TCP(int PORT, int nb_message, int l_msg){
221
+	// Création du socket TCP
222
+	printf("[+] Création du socket local...");
223
+	int s_tcp = socket(AF_INET,SOCK_STREAM, 0);
224
+
225
+	if (s_tcp == -1){
226
+		err_socks();
227
+		return 1;
228
+	} else printf("Ok!\n");
229
+
230
+	struct sockaddr_in servaddr, cliaddr;
231
+	memset(&servaddr, 0, sizeof(servaddr)); 
232
+    memset(&cliaddr, 0, sizeof(cliaddr));
233
+	
234
+	servaddr.sin_family = AF_INET;
235
+    servaddr.sin_addr.s_addr = INADDR_ANY; 
236
+    servaddr.sin_port = PORT; 
237
+
238
+	if (bind(s_tcp, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0) { 
239
+        err_socks();
240
+		return 1;
241
+    }
242
+	printf("[+] Bind ok !\n");
243
+
244
+	if (listen(s_tcp, 5) != 0){
245
+		err_conn();
246
+		return 1;
247
+	}
248
+	printf("[+] Listening on port %d\n", PORT);
249
+
250
+	int s_conn, l_recpt, msg_count = 1;
251
+	int lg_cliaddr = sizeof(cliaddr);
252
+	
253
+	if ((s_conn = accept(s_tcp, (struct sockaddr *)&cliaddr, &lg_cliaddr)) < 0){
254
+		err_conn();
255
+		return 1;
256
+	}
257
+	printf("[+] Connection accepted\n");
258
+
259
+
260
+	int n;
261
+	char buffer[l_msg];
262
+
263
+	printf("[+] Waiting for messages...\n");
264
+	
265
+	while (msg_count <= nb_message || nb_message == -1){
266
+		if ((l_recpt = read(s_conn, buffer, sizeof(buffer))) < 0){
267
+			err_conn();
268
+			return 1;
269
+		}
270
+		if (l_recpt > 0){
271
+		printf("[>] Reception du message n°%d : %s\n", msg_count, buffer);
272
+
273
+		n = 0;
274
+		msg_count++;
275
+		bzero(buffer, l_msg);
276
+		}
277
+	}
278
+
279
+	return 0;
280
+}
281
+
282
+///////////////////////////////////////////////////////////
283
+
284
+/// Main entry
285
+int main (int argc, char **argv)
286
+{	
287
+	int c;
288
+	extern char *optarg;
289
+	extern int optind;
290
+	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
291
+	int source = -1; /* 0 = puits, 1 = source */
292
+	int tcp = 1; /* 0 = UDP, 1 = TCP */
293
+	int l_msg = 30; /* longueur du message, en octet. Defaut : 30. */
294
+
295
+	while ((c = getopt(argc, argv, "pn:su")) != -1) {
296
+		switch (c) {
297
+		case 'p':
298
+			if (source == 1) {
299
+				err_args();
300
+			}
301
+			source = 0;
302
+			break;
303
+
304
+		case 's':
305
+			if (source == 0) {
306
+				err_args();
307
+			}
308
+			source = 1;
309
+			break;
310
+
311
+		case 'n':
312
+			nb_message = atoi(optarg);
313
+			break;
314
+
315
+		case 'u':
316
+			tcp = 0;
317
+			break;
318
+		
319
+		default:
320
+			err_args();
321
+			break;
322
+		}
323
+	}
324
+
325
+	int PORT = atoi(argv[argc-1]);
326
+	//PORT = htons(PORT);
327
+
328
+	if (source == -1) {
329
+		err_args();
330
+	}
331
+
332
+	if (tcp)
333
+		printf("[+] On utilise le protocol TCP\n");
334
+	else 
335
+		printf("[+] On utilise le protocol UDP\n");
336
+	
337
+
338
+	char* HOSTNAME = "";
339
+	if (source == 1){
340
+		printf("[+] On est dans la source\n");
341
+		HOSTNAME = argv[argc-2];
342
+	}
343
+	else
344
+		printf("[+] On est dans le puit\n");
345
+
346
+	if (nb_message != -1) {
347
+		if (source == 1)
348
+			printf("[+] Nombre de tampons à envoyer : %d\n", nb_message);
349
+		else
350
+			printf("[+] Nombre de tampons à recevoir : %d\n", nb_message);
351
+	} else {
352
+		if (source == 1) {
353
+			nb_message = 10 ;
354
+			printf("[~] Nombre de tampons à envoyer : 10 par défaut\n");
355
+		} 
356
+		else
357
+			printf("[+] Nombre de tampons à envoyer : infini\n");
358
+	}
359
+
360
+	if (l_msg == 30) 
361
+		printf("[~] Longueur des messages à envoyer/recevoir : 30 par défaut\n");
362
+	else
363
+		printf("[+] Nombre de tampons à envoyer/recevoir : %d \n", l_msg);
364
+
365
+	int s = 1;
366
+
367
+	// Choose the right function
368
+	if (tcp){
369
+		if (source) s = source_TCP(HOSTNAME, PORT, nb_message, l_msg);
370
+		else s = puit_TCP(PORT, nb_message, l_msg);
371
+	}
372
+	else {
373
+		if (source) s = source_UDP(HOSTNAME, PORT, nb_message, l_msg);
374
+		else s = puit_UDP(PORT, nb_message, l_msg);
375
+	}
376
+
377
+	return s;
378
+}
379
+

+ 387
- 0
tsock_v3_gasc_m.c View File

@@ -0,0 +1,387 @@
1
+/* librairie standard ... */
2
+#include <stdlib.h>
3
+/* pour getopt */
4
+#include <unistd.h>
5
+/* déclaration des types de base */
6
+#include <sys/types.h>
7
+/* constantes relatives aux domaines, types et protocoles */
8
+#include <sys/socket.h>
9
+/* constantes et structures propres au domaine UNIX */
10
+#include <sys/un.h>
11
+/* constantes et structures propres au domaine INTERNET */
12
+#include <netinet/in.h>
13
+/* structures retournées par les fonctions de gestion de la base de
14
+données du réseau */
15
+#include <netdb.h>
16
+/* pour les entrées/sorties */
17
+#include <stdio.h>
18
+/* pour la gestion des erreurs */
19
+#include <errno.h>
20
+
21
+/* 
22
+	TP AIPS
23
+	Version 3 alpha - NON COMPLETE
24
+*/
25
+
26
+///////////////////////////////////////////////////////////
27
+
28
+// Fonctions d'erreurs
29
+/// Afficher l'usage et quitte
30
+void err_args() {
31
+	printf("[!] Usage: cmd [-u][-p|-s][-n ##][-l ##]\n");
32
+	exit(EXIT_FAILURE);
33
+}
34
+
35
+/// Affiche erreur socket
36
+void err_socks(){
37
+	printf("\n[-] Erreur lors de la création/affectation du socket\n");
38
+}
39
+
40
+/// Affiche erreur connexion
41
+void err_conn(){
42
+	printf("\n[-] Erreur lors de la connexion serveur/client\n");
43
+}
44
+
45
+///////////////////////////////////////////////////////////
46
+
47
+
48
+// Given functions
49
+void construire_message(char *message, char motif, int lg, int numero) {
50
+	int i;
51
+	char str[5];
52
+	for (i=0;i<5;++i) str[i] = '-';
53
+	sprintf(str, "%5d", numero);
54
+	for (i=0;i<lg;i++) message[i] = motif;
55
+	for (i=0;i<5;++i) message[i] = str[i];
56
+}
57
+
58
+void afficher_message(char *message, int lg) {
59
+	int i;
60
+	printf("[+] Message construit : ");
61
+	for (i=0;i<lg;i++) printf("%c", message[i]); 
62
+	printf("\n");
63
+}
64
+
65
+///////////////////////////UDP/////////////////////////////
66
+
67
+int source_UDP(char *HOSTNAME, int PORT, int nb_message, int l_msg) {
68
+	// Création du socket UDP
69
+	printf("[+] Création du socket local...");
70
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
71
+
72
+	if (s_udp == -1){
73
+		err_socks();
74
+		return 1;
75
+	} else printf("Ok!\n");
76
+
77
+
78
+	// Création du socket distant
79
+	printf("[+] Création du socket distant...");
80
+	struct sockaddr_in servaddr;
81
+	memset(&servaddr, 0, sizeof(servaddr));
82
+	struct hostent *hp ;
83
+
84
+	// Résolution du nom
85
+	if ((hp = gethostbyname(HOSTNAME)) == NULL) {
86
+		err_conn();
87
+		return 1;
88
+	}
89
+
90
+	// Creation de la struct du socket distant 
91
+	servaddr.sin_family = AF_INET;
92
+	memcpy((char*)&(servaddr.sin_addr.s_addr), hp->h_addr_list[0], hp->h_length);
93
+	servaddr.sin_port = PORT;
94
+	printf("Ok!\n");
95
+
96
+	printf("[+] Envoi des messages à %s:%d...\n", HOSTNAME, PORT);
97
+
98
+	// TEST
99
+	char *pmesg = malloc(l_msg*sizeof(char));
100
+	char c = 'a';
101
+
102
+	// Création des messages à envoyer et envoi
103
+	for (int i = 1; i <= nb_message; i++){
104
+		construire_message(pmesg, c, l_msg, i);
105
+		afficher_message(pmesg, l_msg);
106
+		sendto(s_udp, 
107
+			pmesg, 
108
+			strlen(pmesg), 
109
+			0, 
110
+			(const struct sockaddr *) &servaddr, 
111
+			sizeof(servaddr)
112
+		);
113
+		c++;
114
+		if (c >= '{') c = 'a';
115
+	}
116
+
117
+	return 0;
118
+}
119
+
120
+int puit_UDP(int PORT, int nb_message, int l_msg) {
121
+	// Création du socket UDP
122
+	printf("[+] Création du socket local...");
123
+	int s_udp = socket(AF_INET,SOCK_DGRAM, 0);
124
+
125
+	if (s_udp == -1){
126
+		err_socks();
127
+		return 1;
128
+	} else printf("Ok!\n");
129
+
130
+	struct sockaddr_in servaddr, cliaddr;
131
+	memset(&servaddr, 0, sizeof(servaddr)); 
132
+    memset(&cliaddr, 0, sizeof(cliaddr));
133
+	
134
+	servaddr.sin_family = AF_INET;
135
+    servaddr.sin_addr.s_addr = INADDR_ANY; 
136
+    servaddr.sin_port = PORT; 
137
+
138
+	if ( bind(s_udp, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0 ) { 
139
+        err_socks();
140
+		return 1;
141
+    }
142
+	printf("[+] Bind ok !\n");
143
+
144
+	int n;
145
+	int len;
146
+	int msg_count = 0;
147
+	char buffer[l_msg];
148
+
149
+	printf("[+] Waiting for messages...\n");
150
+	
151
+	while (msg_count >= nb_message || nb_message != -1){
152
+		n = recvfrom(s_udp, (char *)buffer, l_msg,
153
+                MSG_WAITALL, (struct sockaddr *) &cliaddr, 
154
+                &len);
155
+		buffer[n] = '\0';
156
+		printf("[>] Reception du message n°%d : %s\n", msg_count, buffer);
157
+
158
+		n = 0;
159
+		msg_count++;
160
+	}
161
+
162
+	return 0;
163
+}
164
+
165
+////////////////////////////TCP/////////////////////////////
166
+
167
+int source_TCP(char *HOSTNAME, int PORT, int nb_message, int l_msg){
168
+	// Création du socket TCP
169
+	printf("[+] Création du socket local...");
170
+	int s_tcp = socket(AF_INET,SOCK_STREAM, 0);
171
+
172
+	if (s_tcp == -1){
173
+		err_socks();
174
+		return 1;
175
+	} else printf("Ok!\n");
176
+
177
+	// Création du socket distant
178
+	printf("[+] Création du socket distant...");
179
+	struct sockaddr_in servaddr;
180
+	memset(&servaddr, 0, sizeof(servaddr));
181
+	struct hostent *hp ;
182
+
183
+	// Résolution du nom
184
+	if ((hp = gethostbyname(HOSTNAME)) == NULL) {
185
+		err_conn();
186
+		return 1;
187
+	}
188
+
189
+	// Creation de la struct du socket distant 
190
+	servaddr.sin_family = AF_INET;
191
+	memcpy((char*)&(servaddr.sin_addr.s_addr), hp->h_addr_list[0], hp->h_length);
192
+	servaddr.sin_port = PORT;
193
+	printf("Ok!\n");
194
+
195
+	if (connect(s_tcp, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0){
196
+		err_conn();
197
+		return 1;
198
+	}
199
+
200
+
201
+	printf("[+] Envoi des messages...\n");
202
+
203
+	// TEST
204
+	char *pmesg = malloc(l_msg*sizeof(char));
205
+	char c = 'a';
206
+
207
+	// Création des messages à envoyer et envoi
208
+	for (int i = 1; i <= nb_message; i++){
209
+		construire_message(pmesg, c, l_msg, i);
210
+		afficher_message(pmesg, l_msg);
211
+		if (write(s_tcp, pmesg, l_msg) < 0){
212
+			err_conn();
213
+			return 1;
214
+		}
215
+		c++;
216
+		if (c >= '{') c = 'a';
217
+	}
218
+
219
+	close(s_tcp);
220
+
221
+	return 0;
222
+}
223
+
224
+int puit_TCP(int PORT, int nb_message, int l_msg){
225
+	// Création du socket TCP
226
+	printf("[+] Création du socket local...");
227
+	int s_tcp = socket(AF_INET,SOCK_STREAM, 0);
228
+
229
+	if (s_tcp == -1){
230
+		err_socks();
231
+		return 1;
232
+	} else printf("Ok!\n");
233
+
234
+	struct sockaddr_in servaddr, cliaddr;
235
+	memset(&servaddr, 0, sizeof(servaddr)); 
236
+    memset(&cliaddr, 0, sizeof(cliaddr));
237
+	
238
+	servaddr.sin_family = AF_INET;
239
+    servaddr.sin_addr.s_addr = INADDR_ANY; 
240
+    servaddr.sin_port = PORT; 
241
+
242
+	if (bind(s_tcp, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0) { 
243
+        err_socks();
244
+		return 1;
245
+    }
246
+	printf("[+] Bind ok !\n");
247
+
248
+	if (listen(s_tcp, 5) != 0){
249
+		err_conn();
250
+		return 1;
251
+	}
252
+	printf("[+] Listening on port %d\n", PORT);
253
+
254
+	int s_conn, l_recpt, msg_count = 1;
255
+	int lg_cliaddr = sizeof(cliaddr);
256
+	
257
+	if ((s_conn = accept(s_tcp, (struct sockaddr *)&cliaddr, &lg_cliaddr)) < 0){
258
+		err_conn();
259
+		return 1;
260
+	}
261
+	printf("[+] Connection accepted\n");
262
+
263
+
264
+	int n;
265
+	char buffer[l_msg];
266
+
267
+	printf("[+] Waiting for messages...\n");
268
+	
269
+	while (msg_count <= nb_message || nb_message == -1){
270
+		if ((l_recpt = read(s_conn, buffer, sizeof(buffer))) < 0){
271
+			err_conn();
272
+			return 1;
273
+		}
274
+		if (l_recpt > 0){
275
+		printf("[>] Reception du message n°%d : %s\n", msg_count, buffer);
276
+
277
+		n = 0;
278
+		msg_count++;
279
+		bzero(buffer, l_msg);
280
+		}
281
+	}
282
+
283
+	return 0;
284
+}
285
+
286
+///////////////////////////////////////////////////////////
287
+
288
+/// Main entry
289
+int main (int argc, char **argv)
290
+{	
291
+	int c;
292
+	extern char *optarg;
293
+	extern int optind;
294
+	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
295
+	int source = -1; /* 0 = puits, 1 = source */
296
+	int tcp = 1; /* 0 = UDP, 1 = TCP */
297
+	int l_msg = 30; /* longueur du message, en octet. Defaut : 30. */
298
+
299
+	while ((c = getopt(argc, argv, "pn:sul:")) != -1) {
300
+		switch (c) {
301
+		case 'p':
302
+			if (source == 1) {
303
+				err_args();
304
+			}
305
+			source = 0;
306
+			break;
307
+
308
+		case 's':
309
+			if (source == 0) {
310
+				err_args();
311
+			}
312
+			source = 1;
313
+			break;
314
+
315
+		case 'n':
316
+			nb_message = atoi(optarg);
317
+			break;
318
+
319
+		case 'u':
320
+			tcp = 0;
321
+			break;
322
+
323
+		case 'l':
324
+			l_msg = atoi(optarg) + 5;
325
+			break;
326
+		
327
+		default:
328
+			err_args();
329
+			break;
330
+		}
331
+	}
332
+
333
+	int PORT = atoi(argv[argc-1]);
334
+	//PORT = htons(PORT);
335
+
336
+	if (source == -1) {
337
+		err_args();
338
+	}
339
+
340
+	if (tcp)
341
+		printf("[+] On utilise le protocol TCP\n");
342
+	else 
343
+		printf("[+] On utilise le protocol UDP\n");
344
+	
345
+
346
+	char* HOSTNAME = "";
347
+	if (source == 1){
348
+		printf("[+] On est dans la source\n");
349
+		HOSTNAME = argv[argc-2];
350
+	}
351
+	else
352
+		printf("[+] On est dans le puit\n");
353
+
354
+	if (nb_message != -1) {
355
+		if (source == 1)
356
+			printf("[+] Nombre de tampons à envoyer : %d\n", nb_message);
357
+		else
358
+			printf("[+] Nombre de tampons à recevoir : %d\n", nb_message);
359
+	} else {
360
+		if (source == 1) {
361
+			nb_message = 10 ;
362
+			printf("[~] Nombre de tampons à envoyer : 10 par défaut\n");
363
+		} 
364
+		else
365
+			printf("[+] Nombre de tampons à envoyer : infini\n");
366
+	}
367
+
368
+	if (l_msg == 30) 
369
+		printf("[~] Longueur des messages à envoyer/recevoir : 30 par défaut\n");
370
+	else
371
+		printf("[+] Nombre de tampons à envoyer/recevoir : %d \n", l_msg);
372
+
373
+	int s = 1;
374
+
375
+	// Choose the right function
376
+	if (tcp){
377
+		if (source) s = source_TCP(HOSTNAME, PORT, nb_message, l_msg);
378
+		else s = puit_TCP(PORT, nb_message, l_msg);
379
+	}
380
+	else {
381
+		if (source) s = source_UDP(HOSTNAME, PORT, nb_message, l_msg);
382
+		else s = puit_UDP(PORT, nb_message, l_msg);
383
+	}
384
+
385
+	return s;
386
+}
387
+

Loading…
Cancel
Save