Building Reliable Data Transfer on UDP (modified from Assignment 2 of Chapter 2)
In this programming assignment, you will write a reliable data transfer
application based on UDP protocol. Your client will send a simple ping message to a
server, receive a corresponding pong message back from the server, and determine the
delay between when the client sent the ping message and received the pong message.
This delay is called Round Trip Time (RTT).
Your ping program is to send 10 ping messages back to back to the target server
over UDP. For each message, your client is to determine and print the RTT when the
corresponding pong message is returned. Your application should be able to recover
packet losses and send retransmissions when packet loss is determined. To record the
RTT of a particular ping message accurately and to detect packet loss, sequence
numbers should be used and maintained at both the client and the server ends. Thus,
when a pong message is received by the client, the client should know exactly which
ping message that this pong is acknowledging.
When writing your program, please keep in mind that UDP is an unreliable
protocol, a packet sent by the client or server may be lost, and no packet loss detection
and recovery services is provided by UDP. You should design your own mechanism to
handle packet loss detection and retransmission, and record the delays accordingly.
The book resource center provides sample source code for the exercise described
in Assignment 2 of Chapter 2. You may find that set of source code being helpful for this
assignment.
Things to hand in:
1. A thorough description on your application protocol design, how it
handles loss situation, and what triggers the packet retransmission, etc.
2. Your source code
3. Sample screen results of your programs.
Although the book provides its sample code in python, you may choose any
programming language to accomplish this project.