Outline

Further details are given below.

Details

After establishing connection with a server, a client will request a service by sending the server a string: #@#COMPUTE function version argument #@#ENDCOMPUTE. function is a string of at most 50 characters (only upper or lower case letters), which gives the name of a function to compute, version is a version number for the function's definition, which is a string of at most 50 characters (upper or lower case letters, digits, or periods), and argument is a string of digits (at most 9). We will explain "version" further, later.

If this message from the client does not follow the correct format, then the server should send the client a string: #@#ERROR Invalid request #@#ENDERROR and close the socket. Otherwise, it checks to see if it has the definition of this function with the same version number. If it has this function's definition, then it evaluates the function with the desired argument, and sends the result to the client in a string of the form: #@#RESULT answer #@#ENDRESULT, where answer is a string of digits, possibly including a period, representing the value of the function. The server then closes this socket, and the client closes the socket on receipt of the result.

If the server does not have the function's definition, then it sends the following response to the client: #@#DEFINEFUNCTION function version #@#ENDDEFINEFUNCTION, to which the client responds by sending #@#FUNCTIONDEFINITION C-code #@#ENDFUNCTIONDEFINITION, where C-code is C code for the function definition. If this message from the client does not follow the correct format, then the server should send the client a string: #@#ERROR Invalid definition #@#ENDERROR and close the socket.

Note that C-code will not be a complete C program. However, it is guaranteed to have a non-static function called function that takes an int argument and which returns a double. It may contain other (static) functions too, and perhaps static "global" (file scope) variables. The server should be able to save the definition to a C file and compile it with gcc -c and create an object file. (It may and then link it with an appropriate file to create an executable and run it.) The server will ensure that the function is evaluated, and send the result to the client as described earlier. Then the client and server close their sockets, as described earlier.

The version number is useful for the following purpose. Two different clients may define the same function name, say pi. However, the function definitions may be different. We want some mechanism to let clients specify version numbers that are likely to be unique. For example, if I write a client, I may give a version number: ashok.cs.fsu.edu.N, where N will be 1 initially. I may use the same version number in several different service requests to the server, until I change the function definition (for example, if I discovered some error in the previous definition). The first time the server encounters a new ordered pair (function-name,version-number), it will request the client for its definition, and keep a record of having obtained this definition. On subsequent requests for this same pair, it will use the definition it already has.

You should implement a concurrent server using pthreads.

Grading criteria

• Correctness of the server, including handling of the types of errors discussed in class.
• Good programming practices and design.
• Reasonable efficiency.
• Program portability: The clients and servers may run on Linux and Solaris systems. Your program should follow POSIX specifications.
• Makefile that has the correct dependencies, and recompiles only those files that need to be recompiled.
• We may also ask you to demonstrate your program.

Note

Clarification

• You can assume that two different client will not attempt to define the same function with the same version. A client may seek computation of a (function,version) that another client has already defined, but two different clients will not attempt to define the same version of the same function.
• The function name and version number will be sufficiently small that you can create a file name by appending the function name to the version number, with a delimiter in between.
• When the message #@#COMPUTE function version argument #@#ENDCOMPUTE is expected, the server should check for the following errors: (i) the correct tags to start and end the message, (ii) the correct number of fields, and (iii) if argument is a string representing an integer.
• When the message #@#FUNCTIONDEFINITION C-code #@#ENDFUNCTIONDEFINITION is expected, the server should check for the following errors: (i) the correct tags to start and end the message, and (ii) if there is a non-empty string (representing C-code) between the tags (if a non-empty string is present, then you can assume that it contains a correct function definition).
• The server need not actually use the -c option to gcc. It can compile the whole program, including main.
• In order to make the error checking easier, you can assume that a wrong tag will be one of the following: The server is sent #@#FUNCTIONDEFINITION ... #@#ENDFUNCTIONDEFINITION when it expected #@#COMPUTE ... #@#ENDCOMPUTE or it is sent #@#COMPUTE ... #@#ENDCOMPUTE when it expected #@#FUNCTIONDEFINITION ... #@#ENDFUNCTIONDEFINITION.

Example

• A sample client is available at: http://www.cs.fsu.edu/~asriniva/courses/aup02/hws/hw3/hw3test.tar.
• You can run the executable on linprog. Please run the client from the same directory where the two C files (pi0.c and pi1.c) are present.
• Note that this client is not very robust -- it is just meant to verify if your server uses the protocol correctly. In particular, it may not work correctly after a server error.
• Usage:
  • Start it as: client server-address port
  • You can run a sequence of tests by giving certain inputs to stdin. The input will typically consist of a single line with two integers, except that you type a single 0 to end the tests.
  • If the first entry is 1, then the client sends a correct message to the server. If the first entry if 2, then the client sends something incorrect to the server.
  • When the first entry is 1: If the second entry is 0, then the client makes a request for a version the server already has. If the second entry is 1, then it makes a request for a new version. Initially, you must specify 1 as the second entry , since the server does not have any old version.
  • When the first entry is 2: If the second entry is 0, then the client sends a #@#FUNCTIONDEFINITION message when the server expects a #@#COMPUTE message. If the second entry if 1 or 2, then the client sends a #@#COMPUTE message with an incorrect format. If the second entry is 3, then the client sends a #@#COMPUTE message when the server expects a #@#FUNCTIONDEFINITION message. If that entry is 4, then the client sends a #@#FUNCTIONDEFINITION message with an incorrect format.
• Example: (Output from the client is in italics.)
  • client 128.186.120.33 50002
1 0
    INVALID version: You must initially request a new version
    1 1
    
    opening socket
    
    
    opened socket
    
    
    sending request
    
    
    sending #@#COMPUTE pi 1 1000 #@#ENDCOMPUTE
    
    
    sent request
    
    
    receiving response
    
    
    received response
    
    VALID server response: "#@#DEFINEFUNCTION pi 1 #@#ENDDEFINEFUNCTION"
    VALID server response: "#@#RESULT 3.141593 #@#ENDRESULT"
    2 0
    VALID server response: "#@#ERROR Invalid request #@#ENDERROR"
    0
• The client produces several diagnostic messages to help you figure out where the problem might arise. But this is certainly not a substitute for you own test client.