CSS 432
Program 1: Sockets
Instructor: Joe McCarthy
Due date: See the syllabus

1. Purpose

1. exercise the use of various socket-related system calls
2. evaluate the dominant overheads in point-to-point communication over 100Mbps and 1Gbps networks

2. Client-Server Model

• a client process
  1. establishes a connection to a server
  2. sends data or requests for data
  3. closes the connection
• a server process
  1. sends back responses or acknowledgments to the client

3. TCP Communication

To establish such a connection, those processes should perform the following sequence of operations:

Client

1. Receive a server's port number (server_port) and IP name (server_name) as Linux shell command arguments.
2. Retrieve a hostent structure corresponding to this IP name by calling gethostbyname().

       struct hostent* host = gethostbyname( server_name );
   

3. Declare a sockaddr_in structure (defined in ip, the Linux IPv4 protocol implementation), zero-initialize it by calling bzero(), and set its data members as follows (see inet_network for descriptions of inet_ntoa(), which converts the Internet host address in network byte order to a string in IPv4 dotted-decimal notation, and and inet_addr(), which converts an Internet host address from IPv4 dotted-decimal notation into binary data in network byte order; htons() converts an unsigned short integer from host byte order to network byte order):

       int port = YOUR_ID;  // the last 5 digits of your student id
       sockaddr_in sendSockAddr;
       bzero( (char *) &sendSockAddr, sizeof( sendSockAddr ) );
       sendSockAddr.sin_family      = AF_INET; // Address Family Internet
       sendSockAddr.sin_addr.s_addr =
         inet_addr( inet_ntoa( *(struct in_addr *) *host->h_addr_list ) );
       sendSockAddr.sin_port        = htons( server_port );  // convert host byte-order
   

4. Open a stream-oriented socket() with the Internet address family.

       int clientSd = socket( AF_INET, SOCK_STREAM, 0 );
   

5. Connect this socket to the server by calling connect() and passing the following arguments:
   • the socket descriptor (clientSd)
   • the sockaddr_in structure defined above
   • the size of the sockaddr_in structure (obtained via the sizeof() function)

       connect( clientSd, (sockaddr *) &sendSockAddr, sizeof( sendSockAddr ) );
   
   

6. Use the write() or writev() system call to send data (see below).
7. Use the read() system call to receive a response from the server.
8. Close the socket by calling close().

        close( clientSd );
   

Server

1. Declare a sockaddr_in structure, zero-initialize it by calling bzero(), and set its data members as follows (htonl() converts an unsigned long from host byte order to network byte order):

       int port = YOUR_ID;  // the last 5 digits of your student id
       sockaddr_in acceptSockAddr;
       bzero( (char *) &acceptSockAddr, sizeof( acceptSockAddr ) );
       acceptSockAddr.sin_family      = AF_INET; // Address Family Internet
       acceptSockAddr.sin_addr.s_addr = htonl( INADDR_ANY );
       acceptSockAddr.sin_port        = htons( port );
   

2. Open a stream-oriented socket() with the Internet address family.

       int serverSd = socket( AF_INET, SOCK_STREAM, 0 );
   

3. Set the SO_REUSEADDR option (defined in the socket() interface).
   (Note this option is useful to prompt OS to release the server port as soon as your server process is terminated.)

       const int on = 1;
       setsockopt( serverSd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof( int ) );
   

4. Bind this socket to its local address by calling bind() as passing the following arguments:
   • the socket descriptor (serverSd)
   • the sockaddr_in structure defined above
   • the size of the sockaddr_in structure

       bind( serverSd, (sockaddr *) &acceptSockAddr, sizeof( acceptSockAddr ) );
   

5. Instruct the operating system to listen for up to 5 client connection requests at a time by calling listen().

       listen( serverSd, 5 );
   

6. Receive a request from a client by calling accept(), which will return a new socket descriptor specific to each connection request.

       sockaddr_in newSockAddr;
       socklen_t newSockAddrSize = sizeof( newSockAddr );
       int newSd = accept( serverSd, (sockaddr *) &newSockAddr, &newSockAddrSize );
   

7. Use the read() system call to receive data from the client. (Use newSd rather than serverSd in the above code example.)
8. Use the write() system call to send back a response to the client. (Use newSd rather than serverSd in the above code example.)
9. Close the socket by calling close().

       close( newSd );
   

    #include <sys/types.h>    // socket, bind
    #include <sys/socket.h>   // socket, bind, listen, inet_ntoa
    #include <netinet/in.h>   // htonl, htons, inet_ntoa
    #include <arpa/inet.h>    // inet_ntoa
    #include <netdb.h>        // gethostbyname
    #include <unistd.h>       // read, write, close
    #include <string.h>       // bzero
    #include <netinet/tcp.h>  // SO_REUSEADDR
    #include <sys/uio.h>      // writev

Socket.h and Socket.cpp

4. Statement of Work

Client.cpp

1. port: a server port number (last 5 digits of your student ID)
2. nreps: the number of repetitions for sending a set of data buffers
3. nbufs: the number of data buffers
4. bufsize: the size of each data buffer (in bytes)
5. serverIp: a server IP name (e.g., uw1-320-18.uwb.edu or localhost)
6. type: the type of transfer scenario: 1, 2, or 3 (see below)

     char databuf[nbufs][bufsize]; // where nbufs * bufsize = 1500

1. multiple writes: invokes the write() system call for each data buffer, thus invoking as many write() operations as the number of data buffers, (i.e., nbufs).

        for ( int j = 0; j < nbufs; j++ )
          write( sd, databuf[j], bufsize );    // sd: socket descriptor
   

2. writev: allocates an array of iovec data structures, each having its *iov_base field point to a different data buffer as well as storing the buffer size in its iov_len field; and thereafter calls writev() to send all data buffers at once.

        struct iovec vector[nbufs];
        for ( int j = 0; j < nbufs; j++ ) {
          vector[j].iov_base = databuf[j];
          vector[j].iov_len = bufsize;
        }
        writev( sd, vector, nbufs );           // sd: socket descriptor
   

3. single write: allocates an nbufs-sized array of data buffers, and thereafter calls write() to send this array, (i.e., all data buffers) at once.

        write( sd, databuf, nbufs * bufsize ); // sd: socket descriptor
   

1. Open a new socket and establish a connection to a server.
2. Allocate databuf[nbufs][bufsize].
3. Start a timer by calling gettimeofday().
4. Initiate nreps data transfers, each based on type such as 1: multiple writes, 2: writev, or 3: single write
5. Lap the timer by calling gettimeofday(), where lap - start = data-sending time.
6. Receive from the server an integer acknowledgment that shows how many times the server called read().
7. Stop the timer by calling gettimeofday(), where stop - start = round-trip time.
8. Print out the statistics as shown below:

        Test 1: data-sending time = xxx usec, round-trip time = yyy usec, # reads = zzz
   

9. Close the socket.

Server

1. port: a server port number
2. nreps: the number of repetitions of reading data from the client into databuf[BUFSIZE]

1. Accept a new connection.
2. Change this socket into an asynchronous connection using signal() and fcntl().

        signal( SIGIO, your_function ); // you need to define your_function a priori
        fcntl( fd, F_SETOWN, getpid() );
        fcntl( fd, F_SETFL, FASYNC );
   

   [Update: signal() has been deprecated; for an example of using sigaction(), see sigactiondemo.c and socket-server3.c in ~css432/examples.]
3. Let this server sleep forever.

1. Allocate databuf[BUFSIZE], where BUFSIZE = 1500.
2. Start a timer by calling gettimeofday().
3. Repeat (nreps times) reading data from the client into databuf[BUFSIZE]. Note that the read() system call may return without reading the entire data buffer if the network is slow, so you should repeatedly call read() until you've read all the data, e.g.,

          for ( int nRead = 0; 
                ( nRead += read( sd, buf, BUFSIZE - nRead ) ) < BUFSIZE; 
                ++count );
   

   Read the manual page for read() carefully.
4. Stop the timer by calling gettimeofday(), where stop - start = data-receiving time.
5. Send the number of read() calls made, (i.e., the value of count in the code above) as an acknowledgment.
6. Print out the statistics as shown below:

        data-receiving time = xxx usec
   

7. Close this connection.
8. Terminate the server process by calling exit( 0 ).

1. 100Mbps between any two of uw1-320-01 ~ uw1-320-15
2. 1Gbps between any two of uw1-320-16 ~ uw1-320-31

1. nreps = 20000
2. Three combinations of nbufs * bufsize = 15 * 100, 30 * 50, and 60 * 25
3. Three test scenarios such as type = 1, 2, and 3

You can use /sbin/ifconfig and the inet addr field of eth0 to see the IP address of whatever machine you are logged into.

You can use netstat -a to see which ports are currently being used on the machine you are logged into.

5. What to Turn in

6. FAQ

7. Acknowledgment