ICS 651 (Computer Networks) Project 1

The goals of this project are:

1. to learn about signaling
2. to learn about TCP connection establishment and teardown
3. to become familiar with TCP header formats

This is an individual project. You may discuss ideas with your colleagues, but you must be the sole author of all your code.

Your implementation must interoperate with the implementations of at least 2 other people. Your implementation must be in C and compile and run on a Unix system.

The project is due Tuesday, February 16th 1998, at 4pm HST. Submission is electronic:

1. send e-mail to esb@hawaii.edu
2. subject line must be "project 1"
3. body contains your file "tcp.c"
4. your file "tcp.c" must show, in a comment near the beginning:
   1. your full name.
   2. whether you think your program works, and if not, what you think the problem is.
   3. the full name of the people (if any) with whom you have seen your code successfully interoperate.

Signaling is the management of connections by sending special messages. The assignment is to implement the TCP state machine for connection establishment/teardown described starting on page 21 of the TCP specification, RFC 793. To simplify your task, you are not required to implement any of the data transfer, retransmission, and window management operations of TCP, only the connection establishmeent and teardown.

Project Specification

1. int tcp_connect(int IP_address, short local_port, short remote_port) opens a connection to the specified IP address if possible, returning -1 in case of failure (reset received, timeout, destination unreachable). If the connection succeeds, tcp_connect returns a connection identifier, an integer in 1..10 representing the connection.
2. int tcp_listen(short local_port, int * IP_address, int timeout) listens for a connection, and if a connection succeeds, fills in the IP address and returns the connection identifier. If no connection is received within the given timeout (in milliseconds), tcp_listen must return -1.
3. void tcp_close(int connection) closes the connection specified by the argument.
4. void tcp_init() is called exactly once, before any call to connect or listen or close.

1. int ip_send(int IP_address, char * packet, int bytes) will send the given number of bytes pointed to by "packet" to the specified IP address, returning 0. The call may fail (for example if the IP address is unreachable), and then the return value will be -1.
2. int ip_receive(char * packet, int size, int * from, int timeout) returns -1 if the call timed out (timeout is specified in milliseconds). If the call succeeded (did not time out) the packet is filled with data (up to "size" -- any additional data in the packet is discarded), the integer pointed to by "from" is filled with the source IP address, and the number of bytes received is returned.

• source and destination ports -- remember to use big-endian byte order, see also htons and ntohs
• sequence and acknowledgment numbers -- this means you must pick an initial sequence number, and increment it when you send "SYN" or "FIN" packets, as specified in the RFC. Again, remember to send these in big-endian order, perhaps using htonl and ntohl
• the ack, rst, syn, and fin flags
• the "data offset" field always has the value 5, since there are no options and no padding

1. ip.c, implementing a simulated IP (the simulator only works with testtcp.c)
2. testtcp.c, a simple program that calls the TCP functions.
3. tcp.c, a skeleton for your implementation of tcp.c.
4. ipsim.h, used by the C files.
5. makefile, a makefile for this program (might need to be customized for your Unix -- read carefully before using).

• an IP number and four integers:
  1. the simulated IP address
  2. a UDP port number for the simulator
  3. an initial timeout in milliseconds
  4. a TCP port number
  5. a delay in seconds.
  In this case, testtcp.c calls tcp_listen with the specified initial timeout and TCP port number and, if successful, waits the specified number of seconds before closing the connection and exiting.
• an IP number and an integer (the simulated IP adddress and the UDP port number for the local simulator), followed by sets of six parameters:
  1. the (real) IP number and
  2. the UDP port for the remote simulator that we should connect to
  3. the (simulated) IP address being implemented by the remote system
  4. a local and
  5. a remote TCP port number
  6. a duration (in seconds) that the connection should be kept open
  testtcp.c will accept up to ten sets, connect to each system in turn (using tcp_connect), and close each connection after the specified time.

  Note that some of the information given to testtcp.c is stored in global variables used by ip.c.

Details

The call to tcp_connect should time out if more than 10 seconds expire without receiving a packet that was expected by the state machine.

Be sure your TCP works correctly when both sides call tcp_connect (the "SYN-SENT, SYN-RCVD, ESTAB" path through the state machine).

This specification does not ever require you to retransmit a packet.

This specification does not ever require you to transmit a packet with any data. Therefore, the "bytes" parameter to ip_send should always have the value 20. You should check the return value of ip_receive to make sure the packets are 20 bytes long.

See page 36 of the specification to find out when you need to send a reset (cases 1 and 2 only).

To correctly process an incoming reset, assume the window has size 1 byte.

Both ip.c and testtcp.c can be compiled with the "-DDEBUG" flag to enable print statements and to slow down message generation. See the source code for details.

I do make mistakes. If you find mistakes in the design of this protocol, please send mail to me or to the mailing list. I will probably reply within 24 hours (except on weekends). If you are not subscribed to the mailing list, please send a message now with "subscribe ics451-l email firstname lastname" in the body, to listproc@hawaii.edu.