Not Quite TCP: Reliable Communication

In this assignment you will implement a sender for a TCP-like protocol called NQTCP. A receiver is provided that intentionally loses packet and acknowledgements, but otherwise implements the reliable protocol. The underlying protocol is UDP. A framework for the sender is provided that manages the user input and multi-threading concerns.

NQTCP Protocol

Message format

NQTCP messages consist of an 8 byte header followed by data of up to 10 bytes. Note the value of packet length can be much bigger, but you will only be sending up to 10 at a time.

Numbers are stored in Big-Endian format meaning the high order byte of the number is first. For example, if the sequnce number is 522 (0x020A in hex) then the value at data[0] is 2 (0x02) and the value in data[1] is 10 (0x0A).

Header Bytes				Data Bytes
0..1	2..3	4..5	6..7	8..17
Sequence Number	Acknowledgement Number	Packet Length in bytes (including the header)	Unused	Data (optional)

Like TCP, the sequence number represents the location in the data stream for the data carried in the packet. The acknowledgement number indicates the next expected sequence number we will receive from the other end of the communication. Unlike TCP both values start at 1.

Since only the sender will be sending data, the acknowledgement numbers of the packets you send and the sequence numbers of the packets you receive will be 1.

Receiver

The following table lists the events related to the program receiving data and the actions the receiver takes when the events occur.

Event	Actions
Segment received with expected sequence number. No out-of-order packets or delayed ACKs.	Create an ACK. Delay 500 ms before sending it. Update the expected sequence number.
Segment received with expected sequence number and one delayed ACK.	Send one cumulative ACK that covers both this packet and the delayed ACK. Stop timer for the delayed ACK. Update the expected sequence number.
Segment received with expected sequence number and there are waiting out-of-order packets.	Send a cumulative ACK that might include some of the out-of-order packets. Update the expected sequence number.
Receive out-of-order new segment.	Send duplicate ACK with next expected sequence number.
Receive duplicate segment.	Send cumulative ACK.

Sender

The following table described the events that occur in the sender and the actions that the sender should take. The "Method" column refers to the methods that handle the events as required by the assignment.

Method	Event	Actions
sendPacket	App provides data to be transmitted.	Create a new packet. Update the sequence number. Send the packet. Store the packet with unACKed packets. Start the timer, if it isn't already running.
receivePacket	Receive an ACK from the network (special case below)	Remove any acknowledged packets from the unACKed packets. If there are no unACKed packets, stop the timer. Otherwise, restart the timer.
receivePacket	Receive three ACKs with the same ACK number in a row. (Fast Retransmit)	Resend the unACKed packet with the smallest sequence number. Restart the timer.
timeout	Timer times out.	Resend all unACKed packets. Restart the timer.

Assignment

For this assignment you will complete the implementation of MyNQTCPSender.java. Several files are provided for your use. You can find the files in http://cs.gettysburg.edu/~cpresser/cs322/NQTCP/

FIle	Description
NQTCPReceiver.jar	The NQTCPReceiver program. You can run this with the command line java -jar NQTCPReceiver.jar See the NQTCPReceiver section for instructions on how this program works.
NQTCPSender.java	An abstract class containing the framework for sending data. It manages user input as well as additional threads and timers. It also creates the DatagramSocket that is to be used in the subclass MyNQTCPSender. This is the sender's main program. Run this to execute your sender (kill the messanger?) in eclipse or with the command line: java NQTCPSender It optionally takes a hostname on the command line if you prefer running across a network.
MyNQTCPSender.java	A subclass of NQTCPSender with an empty constructor and methods. Your job is to add code to this to make a correct sender.
SampleRun.pdf	Two sample runs with explanations.

MyNQTCPSender.java

To complete the file MyNQTCPSender.java and implement the reliable protocol, you must do the following.

Add instance variables to store and manage unACKed packets.
Add instance variables to keep track of the sequence number and acknowledgement number.
Implement the abstract methods defined in NQTCPSender.java: sendPacket, receivePacket and timeout. As described in the protocol above and in their header comments.
Add any instance variables or helper methods you need to complete the task.
This is the only file you need to edit.

NQTCPSender.java

You do not need to edit this file.
Packets are sent when it reads a line of input.
Characters are sent in groups of 10 or fewer, so you can test multiple messages by typing in a line with more than 9 characters (it also sends the \n character).
The class contains methods for controlling the timer as well as instance variables and constants that you can access in your subclass.

NQTCPReceiver.jar

You do not need to edit the contents of this archive.
Displays each packet along with its status (Received, Sent, Lost etc...)
Enable packet and ACK loss with the radio buttons at the top.
Set the probability of data loss to a value between 0 (no loss) and 1 (all communication lost). This value is only used when packet or ACK loss radio buttons are checked.

Notes

Test your program first with no data loss. Make sure you can send data correctly without errors before trying to manage loss.
Your sender can generate as much output as you would like. My error messages are written to System.err.
Use the DatagramSocket set up by the superclass NQTCPReceiver.java.