Description

During this project, you will implement the simplest of Transport Layer Protocols, the Stop-and-Wait Protocol for the reliable transfer of data through an artificial network. Specifically you will:
• Demonstrate how messages are segmented into packets and how they are reassembled.
• Understand why a checksum is needed and when it is used.
• Understand and implement the Stop-and-Wait Protocol with ACK (Acknowledgments), NACK (Negative Acknowledgments), and re-transmissions.
For a description of the Stop-and-Wait Protocol, read Section 13.6.1 in your textbook.
2 The Protocol Stack
Here is a diagram that shows where the code in this project fits into the protocol stack:

Transport Layer
Network Layer
Link Layer
Physical Layer
client.c

rtp.c
Figure 1: The Protocol Stack
Note that the Network Layer, Link Layer, and Physical Layers are all implemented by your operating system or networking hardware. For the sake of this project, you will be using the UDP transport protocol to emulate an unreliable network layer. The application program, client.c, simply makes the appropriate calls to connect to the remote server, send and receive messages, and disconnect from the remote server. You will be providing the send and receive features for the client to use in rtp.h.
3 Code Walkthrough
$ ./prj5−client 127.0.0.1 8080
1
The client.c program represents the application layer. It uses the services provided by the Transport Layer (rpt.c). It begins by connecting to the remote server. Look at the socket setup() in rpt.c – it creates the UDP socket that is used to emulate an unreliable network. The socket setup() function also initializes and returns a CONN INFO structure. Next, the client program sends a message to the remote server using the rtp send message() function. The client program also receives messages from the network. If the message isn’t available or if the entire message has not been received, then the rtp receive message() function should block until the message has been received from the server. The client program continues to send and receive messages until it is finished. Lastly, the client program calls rtp disconnect() in order to terminate the connection with the remote server. Note that there are four distinct types of Transport Layer packets:
1. DATA is a data packet that contains part of a message in its payload.
2. LAST DATA is just like a data packet, but it also says that it is the last packet for the message.
3. ACK is an acknowledgment that a packet was properly received.
4. NACK is a negative acknowledgment that the packet was not properly received.
5. TERM is used to tell the server to close the connection early (this is not specifically needed for the project).
4 Implementation
4.1 Segmentation of Data
When data is sent over a network, the data is chopped up into one or more parts and each part is sent inside a packet. A packet contains information that describes the message; it contains information such as the source and destination of the packet, the type of data, and the data itself. The data being sent over the network is referred to as the “payload”. Look in rtp.h – what other fields does our network packet carry? Think about why each field is needed. How much payload can we fit into each packet? Note that the packet structure in this project is greatly simplified.
Open up rtp.c and find the packetize() function. Complete this function. Its purpose is to turn a message into an array of packets. It should do the following:
1. Allocate an array of packets big enough to carry all of the data.
2. Populate all the fields of the packet including the payload. Remember, the last packet should be a LAST DATA packet. All other packets should be DATA packets. This is very important! The server does check for this, and it will disconnect if these fields are not filled in properly. If you do not mark the last packet is LAST DATA, the server will hang forever!
3. The “count” variable points to an integer. Update this integer, setting it equal to the length of the array you are returning.
4. Return the array of packets.
4.2 Transport Protocol
Bad things happen in an unreliable network. In the Stop-and-Wait protocol, sending a message requires the following individual steps:
1. Send one packet at a time.
2. After each packet, wait for an ACK or NACK to be received.
3. If a NACK is received, resend the last packet. Otherwise, send the next packet.
Receiving a message requires the following additional steps:
1. Compute the checksum for each packet payload upon arrival.
2. If the checksum does not match the checksum reported in the packet header, send a NACK. If it does match, send an ACK.
Complete the following:
1. Open rtp.c and find the checksum() function. Complete this function. Simply sum up the ASCII values of each character in the buffer and return the sum. This is how the server computes the checksum. The server and the client use this checksum.
2. Open rtp.c and find the rtp receive message() function. This message is for receiving messages from the data connection. To do this, you will use CONN INFO and the recvfrom() function. If the packet is a DATA packet, the payload will be added to the current message buffer. The packet’s payload should only be added to the buffer if the checksum of the data matches the checksum in the packet header. if the checksum matches, you should send an ACK packet using sendto(). If the checksum does not match, then you should send a NACK packet in the same manner.
3. Open rtp.c and find the rtp send message() function. This function should handle packetizing the message and sending the packets one by one using sendto(). You should then accept the server’s response using recvfrom(). If the response is an ACK, you should send the next packet. Otherwise, you should resend the packet. Continue to do this until all of the packets have been sent.
5 Short Answer
Give your answers to the following questions in the provided answers.txt file:
A. How does the protocol implemented in this project ensure that the entirety of a sent message is received?
B. What is the benefit of dividing a message over multiple packets rather than sending it as a single packet?
C. How might you improve the protocol implemented in this project in order to finish sending messages more quickly?
6 Running the Project
To compile all of the code, use the following command:
$ make
1
To run the server on linux, use the following command to run the server:
$ ./prj5−server −p [port number] [−c corruption rate]
1
To run the server on mac, use the following command to run the client:
$ python prj5−server −p [port number] [−c corruption rate]
1
Regardless of operating system, make sure that python is bound to python 2. The server will not run on python 3! Your client should work with an UNMODIFIED version of the server. For example, if you wanted to run a server on port 8080 with a corruption rate of 99%, you would execute the following command:
$ ./prj5−server −p 8080 −c .99
1
If you wanted to run a client that would send messages to this server, you would then execute the following command (in a different terminal):
$ ./prj5−client 127.0.0.1 8080
1
The server will take the client’s messages and then convert them into Pig Latin. The server will be printing out debug statements in order for you to understand what it is doing.
To make a .tar.gz simply execute the following command:
$ make submit
1
Make sure to submit this archive on Canvas.