Computer-Network-Experiment/GoBackN.c at master · Anjiansan/Computer-Network-Experiment · GitHub

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
#include <stdio.h>
#include <string.h>

#include "protocol.h"
#include "datalink.h"

#define DATA_TIMER  2000
#define MAX_SEQ 5U
#define inc(k) if(k<MAX_SEQ) k++;else k=0

typedef enum{false,true} boolean;

static unsigned char buffer[MAX_SEQ+1][PKT_LEN], nbuffered=0;
static unsigned char frame_expected = 0,next_frame_to_send=0,ack_expected=0;
static int phl_ready = 0;

struct FRAME
{
    unsigned char kind; /* FRAME_DATA */
    unsigned char ack;
    unsigned char seq;
    unsigned char data[PKT_LEN];
    unsigned int  padding;
};

static void put_frame(unsigned char *frame, int len)
{
    *(unsigned int *)(frame + len) = crc32(frame, len);
    send_frame(frame, len + 4);
    phl_ready = 0;
}

static void send_data_frame(void)
{
    struct FRAME s;

    s.kind = FRAME_DATA;
    s.seq = next_frame_to_send;
    s.ack = (frame_expected+MAX_SEQ)%(MAX_SEQ+1);
    memcpy(s.data, buffer[next_frame_to_send], PKT_LEN);

    dbg_frame("Send DATA %d %d, ID %d\n", s.seq, s.ack, *(short *)s.data);

    put_frame((unsigned char *)&s, 3 + PKT_LEN);
    start_timer(next_frame_to_send, DATA_TIMER);
}

static void send_ack_frame(void)
{
    struct FRAME s;

    s.kind = FRAME_ACK;
    s.ack = (frame_expected+MAX_SEQ)%(MAX_SEQ+1);

    dbg_frame("Send ACK  %d\n", s.ack);

    put_frame((unsigned char *)&s, 2);
}

/*new add*/
static boolean between(unsigned int a, unsigned int b, unsigned int c)
{
    if((a<=b)&&(b<c)||(c<a)&&(a<=b)||(b<c)&&(c<a))
        return true;
    else
        return false;
}

int main(int argc, char **argv)
{
    protocol_init(argc, argv);
    lprintf("Designed by Jiang Yanjun, build: " __DATE__"  "__TIME__"\n");

    int event, arg;
    struct FRAME f;
    int len = 0;

    disable_network_layer();

    while(true)
    {
        event = wait_for_event(&arg);

        switch (event) {
        case NETWORK_LAYER_READY:
            get_packet(buffer[next_frame_to_send]);
            nbuffered++;
            send_data_frame();
            inc(next_frame_to_send);
            break;

        case PHYSICAL_LAYER_READY:
            phl_ready = 1;
            break;

        case FRAME_RECEIVED:
            len = recv_frame((unsigned char *)&f, sizeof f);
            if (len < 5 || crc32((unsigned char *)&f, len) != 0)
            {
                dbg_event("**** Receiver Error, Bad CRC Checksum\n");
                break;
            }
            if (f.kind == FRAME_ACK)
                dbg_frame("Recv ACK  %d\n", f.ack);
            if (f.kind == FRAME_DATA)
            {
                dbg_frame("Recv DATA %d %d, ID %d\n", f.seq, f.ack, *(short *)f.data);
                if (f.seq == frame_expected)
                {
                    put_packet(f.data, len - 7);
                    inc(frame_expected);
                }
//                send_ack_frame();
            }
            while(between(ack_expected,f.ack,next_frame_to_send))
            {
                nbuffered--;
                stop_timer(ack_expected);
                inc(ack_expected);
            }
//            if (f.ack == frame_nr) {
//                stop_timer(frame_nr);
//                nbuffered--;
//                frame_nr = 1 - frame_nr;
//            }
            break;

        case DATA_TIMEOUT:
            dbg_event("---- DATA %d timeout\n", arg);
            next_frame_to_send=ack_expected;
            int i;
            for(i=1;i<=nbuffered;i++)
            {
                send_data_frame();
                inc(next_frame_to_send);
            }
//            send_data_frame();
            break;
        }

        if (nbuffered < MAX_SEQ && phl_ready)
            enable_network_layer();
        else
            disable_network_layer();
   }
}