• You need to get the basic stop-and-wait retransmission code working.  This can be as simple as the mechanism used in the ARP lab where the sending code went to "sleep" waiting for an acknowledgement to arrive.  If no acknowledgement arrives within 10 seconds, the segment should be sent again(this should already be working from your TCP Connect Lab).
  
  
• Once you have a single segment being transmitted correctly, add code to allow several segments to be transmitted before blocking (waiting for an acknowledgement); hence the suggested use of a semaphore.  The number of segments that can be outstanding is configured through a parameter to the init routine.
  
  
• Each of these segments has its own re-transmission timer.  This can be implemented by having a separate thread for each segment of the window size that uses the sleep(...) call, or by having one thread manage all segments.  The "sleep" implementation is probably easier to code, but will be harder to debug in the long run. You can use the sample setitimer code to cause a method to be called periodically*.  

  A semaphore is used to indicate that all of the segments are currently in use.

  * - If you are familiar with signals and their use within
  a kernel, then this code will make sense. If you have had
  the Hardware class (CS324) or the OS class (CS345) you
  should be familiar with interrupts. Signals are used in a
  similar manner.

Details:

• Note that in this lab, your code needs to be able to function as both client and server.  You still need to run your code against the TA code in order to pass off.
  
• Study the code on pages 103 - 115 and 375-385 (110-120 and 285-292 in the old book) in order to understand the operation of the lab. 
• Start the sequence number at 32000 and increment this value for each additional byte in the segment.
• Remember that the sequence number is associated with the byte(s) in the payload, not with the segment.
• The number sent back in an acknowledgement is the sequence number of the NEXT expected byte. Another way to say this is, "the sequence number after the sequence number of the last byte that was successfully received".

• The flag bits are not defined well in the book.  The bits in the flags field are:
  


• URG=100000
• ACK=010000
• PSH=001000
• RST=000100
• SYN=000010
• FIN=000001

Diagram:

 
 

Specifications:

The TCP layer object will be similar to the other objects you have written in prior labs.  The TCP layer object must support the following methods:

• init ( char *name, protocol *higher, protocol *lower, char *addr, int wsize, int client);
  
  The init(...) code will be called with the addr field containing the TCP port number and the IP address corresponding to this session.  The TCP port will be the first two bytes and the IP address will be the last four bytes.  Save the address so that you can send it as the source address in your packets.  The wsize parameter is the number of segments (not the number of bytes) that you will send before waiting for an acknowledgement.   Plan on window sizes between 4 and 30.
  
  
• push ( char *buf, int len, char *addr);
  
  The push method:
• The addr field contains the TCP port number and the IP address corresponding to this session.  The TCP port will be the first two bytes and the IP address will be the last four bytes.  Use this destination IP address to push the data to the IP layer.
• Call sem_wait to see if the current window is already full.  If so, the sending thread will block (by nature of the semaphore).
• Otherwise, pick an available segment structure, copy the data into that segment structure, create a new thread. Remember to calculate the checksum over the TCP header and the payload data. 
• The thread sends at most 100 bytes to IP push (the maximum segment size is 100 bytes), and "sleeps" for 10 seconds. If an acknowledgement for this segment hasn't been received, resend the segment and "sleep" again.
• Continue sending segments until the whole length has been sent.
  
  
• pop ( char *buf, int len);
  
  The pop method:
  
  • If the connection has not been established, see if this is a SYN, SYN ACK, or the final ACK of a three-way handshake.  If so, then deal with it accordingly(Mark that you recieved that kind of packet so that your connect() and accept() functions can work properly).
    
    
  • See if this is an ACK(not part of the handshake), if so
  • Set the acknowledgement bit in the segment structure, increment the semaphore (see sem_post(...)).

•  connect (unsigned char *other_IP, unsigned char *other_Port) ;
  This function will be the same as the one you wrote in your TCP connect lab.

•  accept (unsigned char *other_IP, unsigned char *other_Port) ;
   This is called when your code is acting as server.  Save away the IP address and port that are passed in.  In this function you should      wait for a SYN packet from the client, send a SYN+ACK packet, then wait for an ACK packet.

Passoff: