Browse Source

Importation du code depuis GitHub

gasc 3 months ago
commit
9f3a45b8b2
2 changed files with 597 additions and 0 deletions
  1. 61
    0
      README.md
  2. 536
    0
      mictcp.c

+ 61
- 0
README.md View File

@@ -0,0 +1,61 @@
1
+# Bureau d'étude réseau - Répertoire de travail
2
+Je mets ici le résultat de mes travaux pour le bureau d'étude réseau de 3ème année MIC à l'INSA de Toulouse. Veuillez noter que je ne mets que `mictcp.c` et que vous allez avoir besoin du reste de l'environnement pour compiler et utiliser le protocole.
3
+
4
+## Avancement 
5
+* La v1 a été implémentée et est parfaitement fonctionnelle.
6
+* La v2 a été implémentée et fonctionne. Aucun paquet n'est perdu (des compteurs permettent de le vérifier) et les performances sont acceptables.
7
+* La v3 est fonctionnelle. Elle peut être testée en mettant DO_HANDSHAKE = 0
8
+* La v4.1 est fonctionnelle et le handshake permet l'échange du ADMITTED_LOSS_RATE
9
+
10
+## Notes pour le correcteur
11
+*Remarque : Ces notes sont disponibles dans l'entête du fichier mictcp.c.*
12
+```
13
+TP BE Réseaux
14
+
15
+ À L'ATTENTION DU CORRECTEUR:
16
+    - Ce fichier est le seul fichier que j'ai modifié 
17
+
18
+    - La v1 a été implémenté et fonctionne avec tsock_texte et 
19
+    tsock_video.
20
+
21
+    - La v2 a été implémentée et reprise de perte ok. Pour tester la
22
+    v2, vous devez faire quelques modifications : 
23
+        * Régler les parametres comme suivant :
24
+            MOD_SEQ_NUM = 2
25
+            ADMITTED_LOSS_RATE = 0
26
+        * Il faut décommenter les lignes commençant par // [V2]
27
+          Ces lignes sont dans la fonction process_received_PDU().
28
+
29
+    - La v3 est implémentée et fonctionnelle. ADMITTED_LOSS_RATE permet de 
30
+    parametrer le taux de paquets perdus abandonnés. S'il vaut 5, alors 5% 
31
+    des paquets perdus ne seront pas renvoyés. Pour tester la v3, passez :
32
+        * DO_HANDSHAKE = 0
33
+    Utiliser cette version permet d'avoir moins de ralentissements, mais au
34
+    prix de coupure et des pertes d'informations.
35
+
36
+    - La v4.1 est implémentée et fonctionnelle. Le handshake permet également 
37
+    d'échanger le taux de pertes admissibles. Pour tester la v3, le handshake
38
+    peut être désactivé avec DO_HANDSHAKE = 0.
39
+    On peut faire plusieurs remarques sur le programme final :
40
+        - Le taux de pertes admis (ADMITTED_LOSS_RATE) est calculé à chaque 
41
+          itération à partir de l'ensemble des pertes et des envoies fait jusqu'à
42
+          présent. On aurait pu implémenter une fenêtre (e.g. avec une pile FIFO, 
43
+          et ça serait plus pertinent pour de longues transmissions) mais il est alors 
44
+          plus difficile d'observer les effets de la v3 et de se s'arrurer que les
45
+          taux de pertes admises sont corrects.
46
+        - La gestion des pertes admissibles est entièrement gérée par la source
47
+          et fonctionne sur le principe du stop and wait uniquement.
48
+
49
+    Améliorations possibles :
50
+    Je vous propose ici quelques idées pour aller plus loin que je n'ai pas eu 
51
+    le temps d'implémenter :
52
+        - Mettre en place de l'asynchronisme entre le client et MIC TCP. Cela pourrait 
53
+        être fait avec un buffer créant une file d'attente avant le stop and wait.
54
+        - Mettre en place le multiplexage, en passant toutes les variables globales
55
+        dans un struct pour chaque socket et utiliser le numéro de port pour identifier
56
+        à quel socket un paquet appartient.
57
+        - Utiliser le RTT plutôt qu'un timeout fixe
58
+        - Regarder l'implémentation de TCP pour le remplacer par MIC-TCP avec par exemple
59
+        l'utilisation de LD_PRELOAD (bon ça, c'est vraiment ambitieux).
60
+```
61
+

+ 536
- 0
mictcp.c View File

@@ -0,0 +1,536 @@
1
+#include <mictcp.h>
2
+#include <api/mictcp_core.h>
3
+
4
+/*
5
+ TP BE Réseaux
6
+
7
+ À L'ATTENTION DU CORRECTEUR :
8
+    - Ce fichier est le seul fichier que j'ai modifié 
9
+
10
+    - La v1 a été implémenté et fonctionne avec tsock_texte et 
11
+    tsock_video.
12
+
13
+    - La v2 a été implémentée et reprise de perte ok. Pour tester la
14
+    v2, vous devez faire quelques modifications : 
15
+        * Régler les parametres comme suivant :
16
+            MOD_SEQ_NUM = 2
17
+            ADMITTED_LOSS_RATE = 0
18
+        * Il faut décommenter les lignes commençant par // [V2]
19
+          Ces lignes sont dans la fonction process_received_PDU().
20
+
21
+    - La v3 est implémentée et fonctionnelle. ADMITTED_LOSS_RATE permet de 
22
+    parametrer le taux de paquets perdus abandonnés. S'il vaut 5, alors 5% 
23
+    des paquets perdus ne seront pas renvoyés. Pour tester la v3, passez :
24
+        * DO_HANDSHAKE = 0
25
+    Utiliser cette version permet d'avoir moins de ralentissements, mais au
26
+    prix de coupure et des pertes d'informations.
27
+
28
+    - La v4.1 est implémentée et fonctionnelle. Le handshake permet également 
29
+    d'échanger le taux de pertes admissibles. Pour tester la v3, le handshake
30
+    peut être désactivé avec DO_HANDSHAKE = 0.
31
+    On peut faire plusieurs remarques sur le programme final :
32
+        - Le taux de pertes admis (ADMITTED_LOSS_RATE) est calculé à chaque 
33
+          itération à partir de l'ensemble des pertes et des envoies fait jusqu'à
34
+          présent. On aurait pu implémenter une fenêtre (e.g. avec une pile FIFO, 
35
+          et ça serait plus pertinent pour de longues transmissions) mais il est alors 
36
+          plus difficile d'observer les effets de la v3 et de se s'arrurer que les
37
+          taux de pertes admises sont corrects.
38
+        - La gestion des pertes admissibles est entièrement gérée par la source
39
+          et fonctionne sur le principe du stop and wait uniquement.
40
+
41
+    Améliorations possibles :
42
+    Je vous propose ici quelques idées pour aller plus loin que je n'ai pas eu 
43
+    le temps d'implémenter :
44
+        - Mettre en place de l'asynchronisme entre le client et MIC TCP. Cela pourrait 
45
+        être fait avec un buffer créant une file d'attente avant le stop and wait.
46
+        - Mettre en place le multiplexage, en passant toutes les variables globales
47
+        dans un struct pour chaque socket et utiliser le numéro de port pour identifier
48
+        à quel socket un paquet appartient.
49
+        - Utiliser le RTT plutôt qu'un timeout fixe
50
+        - Regarder l'implémentation de TCP pour le remplacer par MIC-TCP avec par exemple
51
+        l'utilisation de LD_PRELOAD (bon ça, c'est vraiment ambitieux).
52
+
53
+*/
54
+
55
+
56
+/* RÉGLAGE DES FONCTIONNALITÉES */
57
+// Taux de perte simulé (%)
58
+#define LOSS_RATE 10 
59
+
60
+// Taux de perte admis (%)(pour la v3)
61
+#define ADMITTED_LOSS_RATE 5
62
+
63
+// Nombre de numéros de séquence différents possible (v3 : 2147483646)
64
+#define MOD_SEQ_NUM 2147483646
65
+
66
+// 0: Ne pas utiliser les fonctions connect() et accept()
67
+// 1: Utiliser ces fonctions (facultatif dans le BE)
68
+#define DO_HANDSHAKE 1
69
+
70
+// Niveau de verbositée: 0, faible; 1, fort
71
+#define DEBUG 1
72
+
73
+// Autres parametres
74
+#define MAX_SOCK 10
75
+#define TIMEOUT 2
76
+#define N_S 0
77
+
78
+
79
+
80
+/// Variable globale
81
+// Contient l'ensemble des sockets créés, dans les faits
82
+// seul l'utilisation d'un seul socket a été implémenté (n°0)
83
+mic_tcp_sock tab_sock[MAX_SOCK];
84
+// Contient le loss rate connu
85
+int admitted_loss_rate = 0;
86
+
87
+// Numéros de séquence
88
+int seq_num = 0;
89
+int ack_num = 0;
90
+
91
+
92
+// Compteur permettant de savoir si des packets 
93
+// ont été perdus. --> Aucune pertes pour la v2.
94
+int rcv_c = 0;      /* Compteur de paquets reçus */
95
+int lss_c = 0;      /* Compteur de paquets perdus */
96
+
97
+int snd_c = 0;      /* Compteur de paquets envoyés */
98
+
99
+// Compteur pour la v3
100
+int acc_c = 0;      /* Compteur des pertes renvoyés */
101
+int iac_c = 1;      /* Compteur des pertes abandonnée */
102
+
103
+
104
+
105
+/*
106
+ * Fonction initialisant toutes les composantes d'un PDU
107
+ * à zéro. 
108
+ */
109
+void reset_pdu(mic_tcp_pdu *pdu)
110
+{
111
+    (*pdu).header.source_port = 0;
112
+    (*pdu).header.dest_port = 0;
113
+    (*pdu).header.seq_num = 0;
114
+    (*pdu).header.ack_num = 0;
115
+    (*pdu).header.syn = 0;
116
+    (*pdu).header.ack = 0;
117
+    (*pdu).header.fin = 0;
118
+    (*pdu).payload.data = NULL;
119
+    (*pdu).payload.size = 0;
120
+}
121
+
122
+
123
+/*
124
+ * Permet de créer un socket entre l’application et MIC-TCP
125
+ * Retourne le descripteur du socket ou bien -1 en cas d'erreur
126
+ */
127
+int mic_tcp_socket(start_mode sm)
128
+{
129
+    if (DEBUG)
130
+    {
131
+        printf("[MIC-TCP] Appel de la fonction: ");
132
+        printf(__FUNCTION__);
133
+        printf("\n");
134
+    }
135
+
136
+    int result = -1;
137
+    mic_tcp_sock s;
138
+    result = initialize_components(sm); /* Appel obligatoire */
139
+    s.fd = 0;
140
+
141
+    if (result != -1)
142
+        result = s.fd;
143
+
144
+    set_loss_rate(LOSS_RATE);
145
+    return result;
146
+}
147
+
148
+
149
+/*
150
+ * Permet d’attribuer une adresse à un socket.
151
+ * Retourne 0 si succès, et -1 en cas d’échec
152
+ */
153
+int mic_tcp_bind(int socket, mic_tcp_sock_addr addr)
154
+{
155
+    if (DEBUG)
156
+    {
157
+        printf("[MIC-TCP] Appel de la fonction: ");
158
+        printf(__FUNCTION__);
159
+        printf("\n");
160
+    }
161
+
162
+    // On test que l'identifiant donné est bon
163
+    if (socket < 0 || socket >= MAX_SOCK)
164
+    {
165
+        return -1;
166
+    }
167
+
168
+    tab_sock[socket].state = IDLE;
169
+    tab_sock[socket].addr = addr;
170
+    return 0;
171
+}
172
+
173
+
174
+/*
175
+ * Met le socket en état d'acceptation de connexions
176
+ * Retourne 0 si succès, -1 si erreur
177
+ */
178
+// Fonction implélentée dans le cadre de la v4
179
+int mic_tcp_accept(int socket, mic_tcp_sock_addr *addr)
180
+{
181
+    if (DEBUG)
182
+    {
183
+        printf("[MIC-TCP] Appel de la fonction: ");
184
+        printf(__FUNCTION__);
185
+        printf("\n");
186
+    }
187
+
188
+    int success = 0;
189
+
190
+    if (!DO_HANDSHAKE) {
191
+        admitted_loss_rate = ADMITTED_LOSS_RATE;
192
+        goto skip;
193
+    }
194
+    
195
+    mic_tcp_pdu pdu;
196
+
197
+    // On attend un SYN, process_received_PDU() doit nous le donner
198
+    while (tab_sock[socket].state != SYN_RECEIVED) {}
199
+    printf("[CONNECTION STATE] SYN RCV\n");
200
+
201
+    // Construction du SYN ACK
202
+    reset_pdu(&pdu);
203
+    pdu.header.source_port = tab_sock[socket].addr.port;
204
+    pdu.header.dest_port = addr->port;
205
+    pdu.header.syn = 1;
206
+    pdu.header.ack = 1;
207
+
208
+    // On l'envoie
209
+
210
+    if ((success = IP_send(pdu, *addr)) == -1) {
211
+		return -1;
212
+	}
213
+    printf("[CONNECTION STATE] SYNACK sent.\n");
214
+
215
+    // On attend l'ACK 
216
+    while (tab_sock[socket].state != ESTABLISHED) {
217
+        IP_send(pdu, *addr);
218
+        printf("[CONNECTION STATE] SYNACK re-sent.\n");
219
+    }
220
+    printf("[CONNECTION STATE] ESTABLISHED\n");
221
+    
222
+
223
+    skip:
224
+    tab_sock[socket].state = ESTABLISHED;
225
+    return success;
226
+}
227
+
228
+
229
+/*
230
+ * Permet de réclamer l’établissement d’une connexion
231
+ * Retourne 0 si la connexion est établie, et -1 en cas d’échec
232
+ */
233
+// Fonction implélentée dans le cadre de la v4
234
+int mic_tcp_connect(int socket, mic_tcp_sock_addr addr)
235
+{
236
+    if (DEBUG)
237
+    {
238
+        printf("[MIC-TCP] Appel de la fonction: ");
239
+        printf(__FUNCTION__);
240
+        printf("\n");
241
+    }
242
+
243
+    admitted_loss_rate = ADMITTED_LOSS_RATE;
244
+
245
+    if (!DO_HANDSHAKE) goto skip;
246
+
247
+    int success = -1;
248
+    mic_tcp_pdu pdu, pdu_rcv;
249
+    
250
+    // On vérifie que notre socket est prêt
251
+    if (tab_sock[socket].state != IDLE){
252
+        return -1;
253
+    }
254
+
255
+    // On construit notre pdu SYN et on l'envoie
256
+    printf("[CONNECTION STATE] SYN\n");
257
+    reset_pdu(&pdu);
258
+    pdu.header.dest_port = addr.port;
259
+    pdu.header.syn = 1;
260
+    pdu.payload.data = (char *) &admitted_loss_rate;
261
+    pdu.payload.size = 4;
262
+
263
+    printf("[CONNECTION STATE] Config done. Sending...");
264
+    if ((success = IP_send(pdu, addr)) == -1){
265
+        printf("Fail !\n");
266
+        return -1;
267
+    }
268
+    printf("Done.\n");
269
+
270
+    // On attend le SYN ACK
271
+    while (1){
272
+        printf("[CONNECTION STATE] Wait SYNACK (d.: %d)\n", success);
273
+        reset_pdu(&pdu_rcv);
274
+        success = IP_recv(&pdu_rcv, &addr, TIMEOUT);
275
+        if (pdu_rcv.header.syn == 1 && pdu_rcv.header.ack == 1){
276
+            printf("[CONNECTION STATE] SYNACK, sending ACK.\n");
277
+            pdu.header.syn = 0;
278
+            pdu.header.ack = 1;
279
+            if ((success = IP_send(pdu, addr)) == -1){
280
+                return -1;
281
+            }
282
+            break;
283
+        }
284
+        IP_send(pdu, addr);
285
+    }
286
+    
287
+
288
+    // Connecté !
289
+    skip:
290
+    tab_sock[socket].state = ESTABLISHED;
291
+    tab_sock[socket].addr = addr;
292
+
293
+    if (DEBUG) printf("[CONNECTION STATE] ESTABLISHED\n");
294
+
295
+    return 0;
296
+}
297
+
298
+/*
299
+ * Fonction determinant si une perte est acceptable ou non.
300
+ * Elle effectue des calculs sur integer uniquement pour
301
+ * augmenter sa réactivité.
302
+ */
303
+int is_acceptable(){
304
+    return acc_c * 1000000 / (10000 * (iac_c+acc_c)) < admitted_loss_rate && ADMITTED_LOSS_RATE;
305
+}
306
+
307
+/*
308
+ * Permet de réclamer l’envoi d’une donnée applicative
309
+ * Retourne la taille des données envoyées, et -1 en cas d'erreur
310
+ */
311
+int mic_tcp_send(int mic_sock, char *mesg, int mesg_size)
312
+{
313
+    if (DEBUG) 
314
+    {
315
+        printf("[MIC-TCP] Appel de la fonction: ");
316
+        printf(__FUNCTION__);
317
+        printf("\n");
318
+    }
319
+
320
+    if (tab_sock[mic_sock].state != ESTABLISHED)
321
+        return -1;
322
+
323
+    mic_tcp_pdu pdu, rcv;
324
+    int sq = seq_num;
325
+    int sent_size = -1;
326
+    seq_num = (seq_num + 1) % MOD_SEQ_NUM;
327
+
328
+    reset_pdu(&pdu);
329
+    pdu.header.dest_port = tab_sock[mic_sock].addr.port;
330
+    pdu.header.seq_num = sq;
331
+
332
+    pdu.payload.data = mesg;
333
+    pdu.payload.size = mesg_size;
334
+
335
+    int ok = 0;
336
+    int counted = 0;
337
+    while (!ok)
338
+    {
339
+        if (DEBUG) printf("[DEBUG: mic_tcp_send] Envoi du paquet N°%d...\n", sq);
340
+        sent_size = IP_send(pdu, tab_sock[mic_sock].addr);
341
+
342
+        if (sent_size <= 0){
343
+            printf("[ERREUR] Erreur send().\n");
344
+            return -1;
345
+        }
346
+
347
+        if (DEBUG) printf("[DEBUG: mic_tcp_send] Attente de l'ACK n°%d...\n", sq);
348
+        reset_pdu(&rcv);
349
+        IP_recv(&rcv, &(tab_sock[mic_sock].addr), TIMEOUT);
350
+
351
+
352
+        // Doit-on ne renvoyer pas le paquet ?
353
+        if (rcv.header.ack_num == sq && rcv.header.ack == 1) {
354
+            // Envoi ok.
355
+            ok++;
356
+            snd_c++;
357
+            if (DEBUG) printf("[DEBUG V3] Envoi ok : n°%d (%d/%d)\n", sq, acc_c, iac_c);
358
+        } 
359
+        // Conditions pour la v3 uniquement.
360
+        else if (is_acceptable()) {
361
+            // Envoi nok, mais acceptable
362
+            ok++;
363
+            lss_c++;
364
+            acc_c++;
365
+            if (DEBUG) printf("[DEBUG V3] Perte acceptable : n°%d (%d/%d)\n", sq, acc_c, iac_c);
366
+        }
367
+        else {
368
+            // Envoi nok, inacceptable
369
+            if (!counted) {
370
+                iac_c++;
371
+                counted++;
372
+            }
373
+            if (DEBUG) printf("[DEBUG V3] Perte inacceptable : n°%d (%d/%d)\n", sq, acc_c, iac_c);
374
+        }
375
+    }
376
+
377
+    if (DEBUG) printf("[DEBUG] ACK n°%d reçu. Nb de pckt send : %d\n", rcv.header.ack_num, snd_c);
378
+
379
+    return sent_size;
380
+}
381
+
382
+
383
+/*
384
+ * Permet à l’application réceptrice de réclamer la récupération d’une donnée
385
+ * stockée dans les buffers de réception du socket
386
+ * Retourne le nombre d’octets lu ou bien -1 en cas d’erreur
387
+ * NB : cette fonction fait appel à la fonction app_buffer_get()
388
+ */
389
+int mic_tcp_recv(int socket, char *mesg, int max_mesg_size)
390
+{
391
+    if (DEBUG)
392
+    {
393
+        printf("[MIC-TCP] Appel de la fonction: ");
394
+        printf(__FUNCTION__);
395
+        printf("\n");
396
+    }
397
+
398
+    if (tab_sock[socket].state != ESTABLISHED)
399
+        return -1;
400
+
401
+    mic_tcp_payload payload;
402
+    payload.data = mesg;
403
+    payload.size = max_mesg_size;
404
+
405
+    int read_size = app_buffer_get(payload);
406
+    if (DEBUG) printf("[DEBUG] Read: read_size = %d\n", read_size);
407
+    if (read_size > 0) rcv_c++;
408
+    if (DEBUG) printf("[DEBUG] Nb de pckt recu : %d\n", rcv_c);
409
+
410
+    return read_size;
411
+}
412
+
413
+
414
+/*
415
+ * Permet de réclamer la destruction d’un socket.
416
+ * Engendre la fermeture de la connexion suivant le modèle de TCP.
417
+ * Retourne 0 si tout se passe bien et -1 en cas d'erreur
418
+ */
419
+// Non implémentée cette année, retourne 0 dans tous les cas
420
+int mic_tcp_close(int socket)
421
+{
422
+    if (DEBUG) 
423
+    {
424
+        printf("[MIC-TCP] Appel de la fonction :  ");
425
+        printf(__FUNCTION__);
426
+        printf("\n");
427
+    }
428
+
429
+    tab_sock[socket].state = CLOSED;
430
+    return 0;
431
+}
432
+
433
+
434
+/*
435
+ * Traitement d’un PDU MIC-TCP reçu (mise à jour des numéros de séquence
436
+ * et d'acquittement, etc.) puis insère les données utiles du PDU dans
437
+ * le buffer de réception du socket. Cette fonction utilise la fonction
438
+ * app_buffer_put().
439
+ */
440
+void process_received_PDU(mic_tcp_pdu pdu, mic_tcp_sock_addr addr)
441
+{
442
+    if (DEBUG)
443
+    {
444
+        printf("[MIC-TCP] Appel de la fonction: ");
445
+        printf(__FUNCTION__);
446
+        printf("\n");
447
+    }
448
+
449
+    switch (tab_sock[N_S].state)
450
+    {
451
+    case IDLE:
452
+        if (pdu.header.syn == 1)
453
+        {
454
+            admitted_loss_rate = *((int*)pdu.payload.data);
455
+            if (DEBUG) printf("[CONNECTION STATE] Getting loss rate : %d\n", admitted_loss_rate);
456
+            tab_sock[N_S].state = SYN_RECEIVED;
457
+        }
458
+        else
459
+        {
460
+            if (DEBUG)
461
+                printf("[DEBUG] Paquet ignoré.\n");
462
+        }
463
+        break;
464
+
465
+    case SYN_RECEIVED:
466
+        if (pdu.header.ack == 1)
467
+        {
468
+            tab_sock[N_S].state = ESTABLISHED;
469
+        }
470
+        else
471
+        {
472
+            if (DEBUG)
473
+                printf("[DEBUG] Paquet ignoré.\n");
474
+        }
475
+        break;
476
+
477
+    case CLOSED:
478
+        if (DEBUG) printf("[DEBUG] Reception d'un paquet sur un port fermé\n");
479
+        break;
480
+
481
+    case ESTABLISHED:
482
+        if (DEBUG) printf("[DEBUG: ESTABLISHED] Rcv n°%d, wait n° %d\n", pdu.header.seq_num, ack_num);
483
+        
484
+        // [V2] if (pdu.header.seq_num == ack_num)
485
+        if (pdu.header.seq_num >= ack_num)
486
+        {
487
+            if (DEBUG) printf("[DEBUG] Num ok. In buffer.\n");
488
+            app_buffer_put(pdu.payload);
489
+            
490
+            // [V2] ack_num = (ack_num + 1) % MOD_SEQ_NUM;
491
+            ack_num = pdu.header.seq_num + 1;
492
+
493
+            // Préparation du ACK
494
+            mic_tcp_pdu ack;
495
+            reset_pdu(&ack);
496
+            int s;
497
+
498
+            ack.header.source_port = pdu.header.source_port;
499
+            ack.header.dest_port = addr.port;
500
+            ack.header.ack_num = pdu.header.seq_num;
501
+            ack.header.ack = 1;
502
+
503
+            if (DEBUG) printf("[DEBUG] Envoi du ACK\n");
504
+            if ((s = IP_send(ack, addr)) == -1)
505
+            {
506
+                printf("[ERREUR] Envoi ACK fail.\n");
507
+                return;
508
+            }
509
+        }
510
+        else
511
+        {
512
+            if (DEBUG) printf("[DEBUG] No go.\n");
513
+            mic_tcp_pdu ack;
514
+            reset_pdu(&ack);
515
+            int s;
516
+
517
+            ack.header.source_port = pdu.header.source_port;
518
+            ack.header.dest_port = addr.port;
519
+
520
+            ack.header.ack = 1;
521
+            ack.header.ack_num = pdu.header.seq_num;
522
+
523
+            if (DEBUG) printf("[DEBUG] Envoi du ACK N°%d\n", ack.header.ack_num);
524
+            if ((s = IP_send(ack, addr)) == -1)
525
+            {
526
+                printf("[ERREUR] Envoi ACK fail.\n");
527
+                return;
528
+            }
529
+            if (DEBUG) printf("[DEBUG] Ignored.\n");
530
+        }
531
+        break;
532
+
533
+    default:
534
+        break;
535
+    }
536
+}

Loading…
Cancel
Save