CS 232 Programming Project: Client-Server Computing

Overview: Most Internet applications consist of two components:

• a server that resides on a remote host, providing whatever services are required by the application; and
• a client that a user of the application uses from their local computer to interact with a remote server.

One of the standard TCP/IP services is the echo service, in which a server waits for a client to connect, reads whatever line of text the client sends it as a string, and replies to the client with the same string.

This project is to write the client and server programs for an echo service, with the following extension: If the first line the client sends consists of the word rot13, then for all subsequent lines the server receives from the client, the server rotates the alphabetic characters 13 positions and then replies to the client with those rotated strings.

Details.

The rot13 encoding technique is a simple way to scramble text messages to make them unreadable to the casual reader. (Usenet news groups often display spoilers or offensive material using rot13.)

The mechanism is to "rotate" each alphabetic character 13 positions (maintaining its case), so that alphabetic characters are mapped to one another as follows:

Note that non-alphabetic characters are not rotated -- rot13 only affects alphabetic characters. Thus, the rot13 of adams is nqnzf, the rot13 of Adams is Nqnzf, the rot13 of Nqnzf is Adams, and the rot13 of 123adams456 is 123nqnzf456.

Note also that if we view rot13 as a function, then it is its own inverse function:

  rot13( rot13( aChar ) ) == aChar

You are to write a client program that, using a socket and the TCP protocol, connects to a Rot13Echo server and sends it whatever line of input the user types. Your client should then receive and output the server's response. Your client should continue sending and receiving the user's input, until the user types quit, at which point your client should close its socket and terminate.

Your client should get the server's host-name and port via command-line arguments. To test your client, you may use my Rot13Echo server that is running on acolyte at port 9876; e.g.:

   $ java Rot13EchoClient acolyte 9876

You are also to write your own Rot13Echo server. Your server should open a TCP socket, and listen for a client's connection. When contacted by a client, your server should spawn off a new thread to handle the session with that particular client, and then listen for the next client connection.

Your thread should read the first message from the client. If that first message is rot13, your thread should set a boolean flag to "rotate" all subsequent messages from the client, and then reply to the client with rot13; otherwise, it should just send what it received back to the client.

Once it has processed the first message, your thread should continue to receive messages from its client and either echo them or send those messages rotated, based on the value of your flag.

Your server should get the port it is to use as a command-line argument. For example, if you write your server in Java, you might run it as follows:

  $ java Rot13EchoServer 9876

You may write your system in any of the following languages:

• Java provides the easiest means of building this system, thanks to its standard Thread, Socket and ServerSocket classes. These classes allow you to easily define sockets as distinct objects and manipulate them via object-oriented methods. There are a variety of Java networking tutorials on the WWW that provide the information you need to complete this assignment.
• C/C++ provides the most challenging way to build the system, because there are no standard C++ network interface classes. Instead, the BSD-Unix (C) socket library is used, that allows you to create and manipulate a socket via function calls. C socket programming is thus considerable 'lower level' than Java socket programming. A brief tutorial on C (and Perl) socket programming is available at:

      
  http://www.uwo.ca/its/doc/courses/notes/socket/
    

• Perl provides a Socket package that is intermediate in level between Java's Socket classes and the BSD socket library for C. The functions in this package are similar to those in the BSD socket library, but most of the low-level details are taken care of for you. The following on-line tutorial (as well as the one listed above for C) may be helpful:

     
  http://www.fnal.gov/docs/products/perl/pod.new/5.00503/pod/perlthrtut.html
    

• You may also use other languages, but please clear it with me first.

Strategy.

1. Begin by writing a client that works correctly with my server.
2. When your client is working correctly, write a simple echo server that echoes back to the client whatever it sends.
3. Make your echo server multithreaded, so that it can handle multiple connections simultaneously.
4. Modify your multithreaded echo server so that when the first string it receives is rot13, it rotates the chars in all subsequent strings it receives before sending them back to the client.

Turn in:

A. On acolyte use script to create a file in which you

1. use cat to display your server program (including its thread code);
2. compile your server (unless using a scripting language like Perl);
3. run your server using a port that is not in use.

1. use cat to display your client program;
2. compile your client (unless using a scripting language like Perl);
3. run your client three times, connecting to your server on acolyte. (If you don't manage to finish the server, you can use mine.)

Print your script files and attach a hard copy of this grade sheet.

Due date: Tue, May 8 -- 11:59 p.m.

Note: This assignment will not be accepted following the due date.

CS > 232 > Projects > 5