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

#define MAX_PKT 1024 /* determines packet size in bytes */

typedef enum {false, true} boolean;/* boolean type */
typedef unsigned int seq_nr;/* sequence or ack numbers */
typedef struct {unsigned char data[MAX_PKT];} packet;/* packet definition */
typedef enum {data, ack, nak} frame_kind;
/* frame kind definition */
typedef struct {
    /* frames are transported in this layer */
    frame_kind kind;
    /* what kind of frame is it? */
    seq_nr seq;
    /* sequence number */
    seq_nr ack;
    /* acknowledgement number */
    packet info;
    /* the network layer packet */
} frame;

/* Wait for an event to happen; return its type in event. */
void wait_for_event(event_type *event);
/* Fetch a packet from the network layer for transmission on the channel. */
void from_network_layer(packet *p);
/* Deliver information from an inbound frame to the network layer. */
void to_network_layer(packet *p);
/* Go get an inbound frame from the physical layer and copy it to r. */
void from_physical_layer(frame *r);
/* Pass the frame to the physical layer for transmission. */
void to_physical_layer(frame *s);
/* Start the clock running and enable the timeout event. */
void start_timer(seq_nr k);
/* Stop the clock and disable the timeout event. */
void stop_timer(seq_nr k);
/* Start an auxiliary timer and enable the ack_timeout event. */
void start_ack_timer(void);
/* Stop the auxiliary timer and disable the ack_timeout event. */
void stop_ack_timer(void);
/* Allow the network layer to cause a network layer ready event. */
void enable_network_layer(void);
/* Forbid the network layer from causing a network layer ready event. */
void disable_network_layer(void);
/* Macro inc is expanded in-line: increment k circularly. */
#define inc(k) if (k < MAX_SEQ) k = k + 1; else k = 0

 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

/* Protocol 1 (Utopia) provides for data transmission in one direction only, from
sender to receiver. The communication channel is assumed to be error free
and the receiver is assumed to be able to process all the input infinitely quickly.
Consequently, the sender just sits in a loop pumping data out onto the line as
fast as it can. */
typedef enum {frame_arrival} event_type;
#include "protocol.h"

void sender1(void)
{
    frame s;
    /* buffer for an outbound frame */
    packet buffer;
    /* buffer for an outbound packet */
    while (true) {
        from_network_layer(&buffer);
        /* go get something to send */
        s.info = buffer;
        /* copy it into s for transmission */
        to_physical_layer(&s);
        /* send it on its way */
    }
    /* Tomorrow, and tomorrow, and tomorrow,
    Creeps in this petty pace from day to day
    To the last syllable of recorded time.
    – Macbeth, V, v */
}

void receiver1(void)
{
    frame r;
    event_type event;
    /* filled in by wait, but not used here */
    while (true) {
        wait_for_event(&event);
        /* only possibility is frame_arrival */
        from_physical_layer(&r);
        /* go get the inbound frame */
        to_network_layer(&r.info);
        /* pass the data to the network layer */
    }
}

 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

/* Protocol 2 (Stop-and-wait) also provides for a one-directional flow of data from
sender to receiver. The communication channel is once again assumed to be error
free, as in protocol 1. However, this time the receiver has only a finite buffer
capacity and a finite processing speed, so the protocol must explicitly prevent
the sender from flooding the receiver with data faster than it can be handled. */
typedef enum {frame_arrival} event_type;
#include "protocol.h"
void sender2(void)
{
    frame s;
    /* buffer for an outbound frame */
    packet buffer;
    /* buffer for an outbound packet */
    event_type event;
    /* frame_arrival is the only possibility */
    while (true) {
        from_network_layer(&buffer);
        /* go get something to send */
        s.info = buffer;
        /* copy it into s for transmission */
        to_physical_layer(&s);
        /* bye-bye little frame */
        wait_for_event(&event);
        /* do not proceed until given the go ahead */
    }
}
void receiver2(void)
{
    frame r, s;
    /* buffers for frames */
    event_type event;
    /* frame_arrival is the only possibility */
    while (true) {
        wait_for_event(&event);
        /* only possibility is frame_arrival */
        from_physical_layer(&r);
        /* go get the inbound frame */
        to_network_layer(&r.info);
        /* pass the data to the network layer */
        to_physical_layer(&s);
        /* send a dummy frame to awaken sender */
    }
}

 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

/* Protocol 3 (PAR) allows unidirectional data flow over an unreliable channel. */
#define MAX_SEQ 1
/* must be 1 for protocol 3 */
typedef enum {frame_arrival, cksum_err, timeout} event_type;
#include "protocol.h"
void sender3(void)
{
    seq_nr next_frame_to_send;
    /* seq number of next outgoing frame */
    frame s;
    /* scratch variable */
    packet buffer;
    /* buffer for an outbound packet */
    event_type event;
    next_frame_to_send = 0;
    /* initialize outbound sequence numbers */
    from_network_layer(&buffer);
    /* fetch first packet */
    while (true) {
        s.info = buffer;
        /* construct a frame for transmission */
        s.seq = next_frame_to_send;
        /* insert sequence number in frame */
        to_physical_layer(&s);
        /* send it on its way */
        start_timer(s.seq);
        /* if answer takes too long, time out */
        wait_for_event(&event);
        /* frame_arrival, cksum_err, timeout */
        if (event == frame_arrival) {
            from_physical_layer(&s);
            /* get the acknowledgement */
            if (s.ack == next_frame_to_send) {
                stop_timer(s.ack);
                /* turn the timer off */
                from_network_layer(&buffer);
                /* get the next one to send */
                inc(next_frame_to_send);
                /* invert next_frame_to_send */
            }
        }
    }
}
void receiver3(void)
{
    seq_nr frame_expected;
    frame r, s;
    event_type event;
    frame_expected = 0;
    while (true) {
        wait_for_event(&event);
        /* possibilities: frame_arrival, cksum_err */
        if (event == frame_arrival) {
            /* a valid frame has arrived */
            from_physical_layer(&r);
            /* go get the newly arrived frame */
            if (r.seq == frame_expected) {
                /* this is what we have been waiting for */
                to_network_layer(&r.info);
                /* pass the data to the network layer */
                inc(frame_expected);
                /* next time expect the other sequence nr */
            }
            s.ack = 1 − frame_expected;
            /* tell which frame is being acked */
            to_physical_layer(&s);
            /* send acknowledgement */
        }
    }
}

 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

/* Protocol 4 (Sliding window) is bidirectional. */
#define MAX_SEQ 1
/* must be 1 for protocol 4 */
typedef enum {frame_arrival, cksum_err, timeout} event_type;
#include "protocol.h"
void protocol4 (void)
{
    seq_nr next_frame_to_send;
    /* 0 or 1 only */
    seq_nr frame_expected;
    /* 0 or 1 only */
    frame r, s;
    /* scratch variables */
    packet buffer;
    /* current packet being sent */
    event_type event;
    next_frame_to_send = 0;
    /* next frame on the outbound stream */
    frame_expected = 0;
    /* frame_expected next */
    from_network_layer(&buffer);
    /* fetch a packet from the network layer */
    s.info = buffer;
    /* prepare to send the initial frame */
    s.seq = next_frame_to_send;
    /* insert sequence number into frame */
    s.ack = 1 − frame_expected;
    /* piggybacked ack */
    to_physical_layer(&s);
    /* transmit the frame */
    start_timer(s.seq);
    /* start the timer running */
    while (true) {
        wait_for_event(&event);
        /* frame_arrival, cksum_err, or timeout */
        if (event == frame_arrival) {
            /* a frame has arrived undamaged */
            from_physical_layer(&r);
            /* go get it */
            if (r.seq == frame_expected) {
                /* handle inbound frame stream */
                to_network_layer(&r.info);
                /* pass packet to_network_layer */
                inc(frame_expected);
                /* invert seq number expected next */
            }
            if (r.ack == next_frame_to_send) {
                /* handle outbound frame stream */
                stop_timer(r.ack);
                /* turn the timer off */
                from_network_layer(&buffer);
                /* fetch new pkt from_network_layer */
                inc(next_frame_to_send);
                /* invert sender’s sequence number */
            }
        }
        s.info = buffer;
        /* construct outbound frame */
        s.seq = next_frame_to_send;
        /* insert sequence number into it */
        s.ack = 1 − frame_expected;
        /* seq number of last received frame */
        to_physical_layer(&s);
        /* transmit a frame */
        start_timer(s.seq);
        /* start the timer running */
    }
}

  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

/* Protocol 5 (Go-back-n) allows multiple outstanding frames. The sender may transmit up
to MAX_SEQ frames without waiting for an ack. In addition, unlike in the previous
protocols, the network layer is not assumed to have a new packet all the time. Instead,
the network layer causes a network layer ready event when there is a packet to send. */
#define MAX_SEQ 7
typedef enum {frame_arrival, cksum_err, timeout, network_layer_ready} event_type;
#include "protocol.h"
static boolean between(seq_nr a, seq_nr b, seq_nr c)
{
    /* Return true if a <= b < c circularly; false otherwise. */
    if (((a <= b) && (b < c)) || ((c < a) && (a <= b)) || ((b < c) && (c < a)))
        return(true);
    else
        return(false);
}
static void send_data(seq_nr frame_nr, seq_nr frame_expected, packet buffer[ ])
{
    /* Construct and send a data frame. */
    frame s;
    /* scratch variable */
    s.info = buffer[frame_nr];
    /* insert packet into frame */
    s.seq = frame_nr;
    /* insert sequence number into frame */
    s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1);/* piggyback ack */
    to_physical_layer(&s);
    /* transmit the frame */
    start_timer(frame_nr);
    /* start the timer running */
}
void protocol5(void)
{
    seq_nr next_frame_to_send;
    /* MAX_SEQ > 1; used for outbound stream */
    seq_nr ack_expected;
    /* oldest frame as yet unacknowledged */
    seq_nr frame_expected;
    /* next frame_expected on inbound stream */
    frame r;
    /* scratch variable */
    packet buffer[MAX_SEQ + 1];
    /* buffers for the outbound stream */
    seq_nr nbuffered;
    /* number of output buffers currently in use */
    seq_nr i;
    /* used to index into the buffer array */
    event_type event;
    enable_network_layer();
    /* allow network layer ready events */
    ack_expected = 0;
    /* next ack_expected inbound */
    next_frame_to_send = 0;
    /* next frame going out */
    frame_expected = 0;
    /* number of frame_expected inbound */
    nbuffered = 0;
    /* initially no packets are buffered */
    while (true) {
        wait_for_event(&event);
        /* four possibilities: see event_type above */
        switch(event) {
        case network_layer_ready:
            /* the network layer has a packet to send */
            /* Accept, save, and transmit a new frame. */
            from_network_layer(&buffer[next_frame_to_send]); /* fetch new packet */
            nbuffered = nbuffered + 1;
            /* expand the sender’s window */
            send_data(next_frame_to_send, frame_expected, buffer);/* transmit the frame */
            inc(next_frame_to_send);
            /* advance sender’s upper window edge */
            break;
        case frame_arrival:
            /* a data or control frame has arrived */
            from_physical_layer(&r);
            /* get incoming frame from_physical_layer */
            if (r.seq == frame_expected) {
                /* Frames are accepted only in order. */
                to_network_layer(&r.info);
                /* pass packet to_network_layer */
                inc(frame_expected);
                /* advance lower edge of receiver’s window */
            }
            /* Ack n implies n − 1, n − 2, etc. Check for this. */
            while (between(ack_expected, r.ack, next_frame_to_send)) {
                /* Handle piggybacked ack. */
                nbuffered = nbuffered − 1;
                /* one frame fewer buffered */
                stop_timer(ack_expected);
                /* frame arrived intact; stop_timer */
                inc(ack_expected);
                /* contract sender’s window */
            }
            break;
        case cksum_err: break;
        /* just ignore bad frames */
        case timeout:
            /* trouble; retransmit all outstanding frames */
            next_frame_to_send = ack_expected;
            /* start retransmitting here */
            for (i = 1; i <= nbuffered; i++) {
                send_data(next_frame_to_send, frame_expected, buffer);/* resend_frame */
                inc(next_frame_to_send);
                /* prepare to send the next one */
            }
        }
        if (nbuffered < MAX_SEQ)
            enable_network_layer();
        else
            disable_network_layer();
    }
}

  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

/* Protocol 6 (Selective repeat) accepts frames out of order but passes packets to the
network layer in order. Associated with each outstanding frame is a timer. When the timer
expires, only that frame is retransmitted, not all the outstanding frames, as in protocol 5. */
#define MAX_SEQ 7
/* should be 2ˆn − 1 */
#define NR_BUFS ((MAX_SEQ + 1)/2)
typedef enum {frame_arrival, cksum_err, timeout, network_layer_ready, ack_timeout} event_type;
#include "protocol.h"
boolean no_nak = true;
/* no_nak has been sent yet */
seq_nr oldest_frame = MAX_SEQ + 1;
/* initial value is only for the simulator */
static boolean between(seq_nr a, seq_nr b, seq_nr c)
{
    /* Same as between in protocol 5, but shorter and more obscure. */
    return ((a <= b) && (b < c)) || ((c < a) && (a <= b)) || ((b < c) && (c < a));
}
static void send_frame(frame_kind fk, seq_nr frame_nr, seq_nr frame_expected, packet buffer[ ])
{
    /* Construct and send a data, ack, or nak frame. */
    frame s;
    /* scratch variable */
    s.kind = fk;

    /* kind == data, ack, or nak */
    if (fk == data)
        s.info = buffer[frame_nr % NR_BUFS];

    s.seq = frame_nr;
    /* only meaningful for data frames */
    s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1);

    if (fk == nak)
        no_nak = false;
    /* one nak per frame, please */

    to_physical_layer(&s);
    /* transmit the frame */

    if (fk == data)
        start_timer(frame_nr % NR_BUFS);

    stop_ack_timer();
    /* no need for separate ack frame */
}
void protocol6(void)
    {
    seq_nr ack_expected;
    /* lower edge of sender’s window */
    seq_nr next_frame_to_send;
    /* upper edge of sender’s window + 1 */
    seq_nr frame_expected;
    /* lower edge of receiver’s window */
    seq_nr too far;
    /* upper edge of receiver’s window + 1 */
    int i;
    /* index into buffer pool */
    frame r;
    /* scratch variable */
    packet out_buf[NR_BUFS];
    /* buffers for the outbound stream */
    packet in_buf[NR_BUFS];
    /* buffers for the inbound stream */
    boolean arrived[NR_BUFS];
    /* inbound bit map */
    seq_nr nbuffered;
    /* how many output buffers currently used */
    event_type event;
    enable_network_layer();
    /* initialize */
    ack_expected = 0;
    /* next ack_expected on the inbound stream */
    next_frame_to_send = 0;
    /* number of next outgoing frame */
    frame_expected = 0;
    too_far = NR_BUFS;
    nbuffered = 0;
    /* initially no packets are buffered */
    for (i = 0; i < NR_BUFS; i++) arrived[i] = false;
    while (true) {
        wait_for_event(&event);
        /* five possibilities: see event_type above */
        switch(event) {
        case network_layer_ready:
            /* accept, save, and transmit a new frame */
            nbuffered = nbuffered + 1;
            /* expand the window */
            from_network_layer(&out_buf[next_frame_to_send % NR_BUFS]); /* fetch new packet */
            send_frame(data, next_frame_to_send, frame_expected, out_buf);/* transmit the frame */
            inc(next_frame_to_send);
            /* advance upper window edge */
            break;
        case frame_arrival:
            /* a data or control frame has arrived */
            from_physical_layer(&r);
            /* fetch incoming frame from_physical_layer */
            if (r.kind == data) {

                /* An undamaged frame has arrived. */
                if ((r.seq != frame_expected) && no_nak)
                    send_frame(nak, 0, frame_expected, out_buf);
                else
                    start_ack_timer();

                if (between(frame_expected,r.seq,too far) && (arrived[r.seq%NR_BUFS]==false)) {
                    /* Frames may be accepted in any order. */
                    arrived[r.seq % NR_BUFS] = true;
                    /* mark buffer as full */
                    in_buf[r.seq % NR_BUFS] = r.info;
                    /* insert data into buffer */
                    while (arrived[frame_expected % NR_BUFS]) {
                        /* Pass frames and advance window. */
                        to_network_layer(&in_buf[frame_expected % NR_BUFS]);
                        no_nak = true;
                        arrived[frame_expected % NR_BUFS] = false;
                        inc(frame_expected);
                        /* advance lower edge of receiver’s window */
                        inc(too far);
                        /* advance upper edge of receiver’s window */
                        start_ack_timer();
                        /* to see if a separate ack is needed */
                    }
                }
            }

            if((r.kind==nak) && between(ack_expected,(r.ack+1)%(MAX_SEQ+1),next_frame_to_send))
                send_frame(data, (r.ack+1) % (MAX_SEQ + 1), frame_expected, out_buf);

            while (between(ack_expected, r.ack, next_frame_to_send)) {
                nbuffered = nbuffered − 1;
                /* handle piggybacked ack */
                stop_timer(ack_expected % NR_BUFS);
                /* frame arrived intact */
                inc(ack_expected);
            /* advance lower edge of sender’s window */
            }
            break;
        case cksum_err:
            if (no_nak)
            send_frame(nak, 0, frame_expected, out_buf); /* damaged frame */
            break;
        case timeout:
            send_frame(data, oldest_frame, frame_expected, out_buf); /* we timed out */
            break;
        case ack_timeout:
            send_frame(ack,0,frame_expected, out_buf);
            /* ack timer expired; send ack */
        }
        if (nbuffered < NR_BUFS)
            enable_network_layer();
        else
            disable_network_layer();
    }
}

 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

#define MAX_NODES 1024
/* maximum number of nodes */
#define INFINITY 1000000000
/* a number larger than every maximum path */
int n, dist[MAX_NODES][MAX_NODES];
/* dist[i][j] is the distance from i to j */
void shortest path(int s, int t, int path[])
{
    struct state {
        /* the path being worked on */
        int predecessor;
        /* previous node */
        int length;
        /* length from source to this node */
        enum {permanent, tentative} label;
        /* label state */
    } state[MAX_NODES];

    int i, k, min;
    struct state *p;
    for (p = &state[0]; p < &state[n]; p++) {
        /* initialize state */
        p->predecessor = −1;
        p->length = INFINITY;
        p->label = tentative;
    }
    state[t].length = 0; state[t].label = permanent;
    k = t;
    /* k is the initial working node */
    do {
        /* Is there a better path from k? */
        for (i = 0; i < n; i++){ //n node
            if (dist[k][i] != 0 && state[i].label == tentative) {
                if (state[k].length + dist[k][i] < state[i].length) {
                    state[i].predecessor = k;
                    state[i].length = state[k].length + dist[k][i];
                }
            }
        }
        /* Find the tentatively labeled node with the smallest label. */
        k = 0; min = INFINITY;
        for (i = 0; i < n; i++){
            if (state[i].label == tentative && state[i].length < min) {
                min = state[i].length;
                k = i;
            }
        }
        state[k].label = permanent;
    } while (k != s);
    /* Copy the path into the output array. */
    i = 0; k = s;
    do {path[i++] = k; k = state[k].predecessor; } while (k >= 0);
}

 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

/* This page contains a client program that can request a file from the server program
 * on the next page. The server responds by sending the whole file.
 */
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define SERVER_PORT 8080
/* arbitrar y, but client & server must agree */
#define BUF_SIZE 4096
/* block transfer size */
int main(int argc, char** argv)
{
    int c, s, bytes;
    char buf[BUF_SIZE];
    /* buffer for incoming file */
    struct hostent* h;
    /* info about server */
    struct sockaddr in_channel;
    /* holds IP address */
    if (argc != 3)
    {
        printf("Usage: client server-name file-name");
        exit(-1);
    }
    h = gethostbyname(argv[1]);
    /* look up host’s IP address */
    if (!h)
    {
        printf("gethostbyname failed to locate %s", argv[1]);
        exit(-1);
    }
    s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (s < 0)
    {
        printf("socket call failed");
        exit(-1);
    }

    memset(&channel, 0, sizeof(channel));
    channel.sin_family = AF_INET;
    memcpy(&channel.sin_addr.s_addr, h->h_addr, h->h_length);
    channel.sin_port = htons(SERVER_PORT);
    c = connect(s, (struct sockaddr*)&channel, sizeof(channel));

    if (c < 0)
    {
        printf("connect failed");
        exit(-1);
    }

    /* Connection is now established. Send file name including 0 byte at end. */
    write(s, argv[2], strlen(argv[2]) + 1);
    /* Go get the file and write it to standard output. */
    while (1)
    {
        bytes = read(s, buf, BUF_SIZE);
        /* read from socket */

        if (bytes <= 0)
            exit(0);

        /* check for end of file */
        write(1, buf, bytes);
        /* wr ite to standard output */
    }
}

 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

#include <sys/types.h>
/* This is the server code */
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/fcntl.h>
#include <sys/socket.h>

#define SERVER_PORT 8080
/* arbitrar y, but client & server must agree */
#define BUF_SIZE 4096
/* block transfer size */
#define QUEUE_SIZE 10
int main(int argc, char* argv[])
{
    int s, b, l, fd, sa, bytes, on = 1;
    char buf[BUF_SIZE];
    /* buffer for outgoing file */
    struct sockaddr_in channel;
    /* holds IP address */
    /* Build address structure to bind to socket. */
    memset(&channel, 0, sizeof(channel));
    /* zero channel */
    channel.sin_family = AF_INET;
    channel.sin_addr.s_addr = htonl(INADDR_ANY);
    channel.sin + port = htons(SERVER_PORT);

    /* Passive open. Wait for connection. */
    s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    /* create socket */
    if (s < 0)
    {
        printf("socket call failed");
        exit(-1);
    }

    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
    b = bind(s, (struct sockaddr*)&channel, sizeof(channel));

    if (b < 0)
    {
        printf("bind failed");
        exit(-1);
    }

    l = listen(s, QUEUE_SIZE);
    /* specify queue size */
    if (l < 0)
    {
        printf("listen failed");
        exit(-1);
    }

    /* Socket is now set up and bound. Wait for connection and process it. */
    while (1)
    {
        sa = accept(s, 0, 0);
        /* block for connection request */
        if (sa < 0)
        {
            printf("accept failed");
            exit(-1);
        }
        read(sa, buf, BUF_SIZE);
        /* read file name from socket */
        /* Get and return the file. */
        fd = open(buf, O_RDONLY);
        /* open the file to be sent back */
        if (fd < 0)
        {
            printf("open failed");
        }
        while (1)
        {
            bytes = read(fd, buf, BUF_SIZE); /* read from file */
            if (bytes <= 0)
                break;
            /* check for end of file */
            write(sa, buf, bytes);
            /* wr ite bytes to socket */
        }
        close(fd);
        /* close file */
        close(sa);
        /* close connection */
    }
}