Chapter 36 -- dynamic web document technologies

(rev. 01/26/2008)

Notes On Chapter Thirty-Six -- Dynamic Web Document Technologies (CGI, ASP, JSP, PHP, ColdFusion)

36.1 Introduction
- We discuss web technology that allows a web page to change each time it is accessed.
36.2 Three Basic Types of Web Documents
- Static:
  - A static document resides in a file on a web server.
  - The server transfers the same file in response to every client request for the URL of the document.
- Dynamic:
  - Using a program, the server creates a new version of the document in response to each client request for the document's URL.
  - The document can be different for each client request.
- Active:
  - In response to the request from the client the server sends a program to the client.
  - The client runs the program to display and interact with the document.
  - The program can continuously update the display.
36.3 Advantages and Disadvantages of Each Document Type
- Static:
  - advantages: simple, reliable, efficient
  - disadvantages: inflexible - it can be inconvenient and costly to change static documents.
- Dynamic:
  - advantages: provides current information
  - disadvantages:
    - document cannot change after reaching the client;
    - creators must have knowledge of programming;
    - greater demand is placed on servers;
    - it tends to take longer for the server to execute the program and transmit the document to the client;
- Active:
  - advantages: can update the browser user's screen continuously
  - disadvantages:
    - cost of creating, testing, and running;
    - security: documents can export information;
    - requires more sophisticated browser and more powerful computer;
    - care must be taken that the programs are portable.
36.4 Implementation of Dynamic Documents
- A server that handles requests for dynamic documents must interpret the URL's that clients include with their requests.
- Information must be encoded in the URL's to allow the server to determine whether the client is requesting a static document or a dynamic document.
- There has to be a program on the server for each possible type of dynamic document request.
- When a client requests a dynamic document, the server must execute the corresponding program, capture the output, and send it to the client.
36.5 The CGI Standard
- CGI stands for Common Gateway Interface
- It is a popular standard for implementing dynamic documents.
36.6 Output From A CGI Program
- A CGI program outputs a header followed optionally by a 'document'.
- The document generally can be of any type. It does not have to be HTML. For example, the document could be plain text, word processor format, or an image file format.
- The header typically contains information about the data type of the document.
- The server reads the header returned by the CGI program. Therefore the server can modify its actions based on information in the header.
- For example, the header can instruct the server to return a static document from a specified location.
  
  Try: http://pollux.csustan.edu/cgi-bin/jspage
  
  That URL takes the browser to a copy of my homepage that is stored in pollux:///user/student/jsclass/public_html/js.html. The CGI program directly referenced by the URL looks like this:
```
#!/bin/sh

#
# CS 3000 Demo
# This demonstrates CGI's ability to redirect from one URL to another
# 

echo Location: /~jsclass/js.html
echo
```
36.7 An Example CGI Program
- When executed, the shell script below first outputs a header using the unix echo command.
```
#!/bin/sh
#
# CS 3000 Demo
# CGI script that prints the 
# date and time at which it was run
#
# Output the document header 
# followed by a blank line 

echo Content-type: text/plain
echo  

# Output the date  

echo This document was created on `date` 
```
- Next it executes the unix date command and relays its output.
- For example, if executed at 00:25:48 Pacific Daylight Time on May 9, 2007, the script would output:
```
Content-type: text/plain

This document was created on Wed May 9 00:25:48 PDT 2007
```
- Example: After reading these directions, click on the URL below. Then click on the refresh button several times while watching the screen. Finally click on the back button to return here.
  
  The sample CGI program: http://pollux.csustan.edu/cgi-bin/date
- Notice that the display changed when you hit the refresh key. That is because the client send the URL to the server again each time, and the server runs the program to generate a new document. The documents change as the time of day changes.
- The "cgi-bin" component in the URL is the signal to the server that this is a request for a dynamic document. The name of the program to run is the last component of the URL: date.
36.8 Parameters and Environment Variables
- The CGI standard allows a client to send parameter values to the server, which can then pass them along to the CGI program. The program typically uses parameters to tailor the output to the needs of the client.
- A '?' is used to separate the parameter values from the part of the URL that denotes which CGI program to use.
- The server also passes along other information to the CGI program as indicated by the chart below.
- Try running the "printenv" CGI below. It outputs the information it has received from the server. You can see all the information mentioned in the chart above and more.
  
  http://pollux.csustan.edu/cgi-bin/printenv?SHOW+ME+SPORTS+JACKETS
36.9 State Information and Cookies
- A server can give a browser a cookie: a small amount of information (a name/value pair) describing the outcome of previous interactions the browser had with the server site. The browser normally sends the cookie back to the server each time it makes a new request. This allows the dynamic documents to be more "conversational" with the user of the browser.
- Cookies are small and can't represent much information. However a server may store any amount of information about a client in a database and use a cookie sent by a client as a key to look up information in the database.
- Typically cookies are stored in a file on the client, but a session cookie exists only in primary memory and is discarded when the browser exits.
- There are alternatives. A CGI program can put state information in a file or in the dynamic document it creates. (See the next section).

36.10 A CGI Script With Long-Term State Information

The script below illustrates that a CGI program can store long-term state information in a file.
The example is trivial but indicates that it is possible to store all information received from a client.

Take some time to examine the script and figure out what it does.

#!/bin/sh 
FILE=ipaddrs

echo Content-type: text/plain
echo  

# See if IP address of browser's
# computer appears in our file  

if grep -s $REMOTE_ADDR $FILE > /dev/null 2>&1
then
   echo Computer $REMOTE_ADDR has requested this URL previously.
else 
   # Append browser's address to the file  
   echo $REMOTE_ADDR >> $FILE
   echo This is the first contact from computer $REMOTE_ADDR
fi

Run the script: http://pollux.csustan.edu/cgi-bin/IP_Memory

36.11 A CGI Script With Short-Term State Information

The string after the '?' (the QUERY_STRING) is passed to the dynamic document program.
Each time the program is invoked, it can create a different document, with changes based on the content of the string.
The program can use the information in the QUERY_STRING to create URL's to put into anchors within the web page it generates.

Consider the example script below which counts the number of times it is 'visited.'


#!/bin/sh
# CS 3000 Demo 
# CGI script that maintains short-term state,
# counting the number of accesses to it. 

# Output the document header followed by a blank line 
echo Content-type: text/html
echo 

# Make a shell variable out of the 'arguments' 
# portion of the client's URL  
N=$QUERY_STRING 

# emit the first few characters of a web page  
echo "<HTML>"

case "x$N" in 

# in case of 'empty argument' set the variable N to 1, and 
# make the web page say this is the initial page 
x)     N=1
       echo "This is the initial page.<BR><BR>"
       ;; 

# case of N = a number - add one to the number, and 
# arrange for the user to see the new number in the web page. 
x[0-9]*)  N=`expr $N + 1`;
          echo "You have displayed this page $N times.<BR><BR>"
          ;; 
	  
# Otherwise declare an error. 
*)        echo "The URL you used is invalid.</HTML>"
          exit 0
          ;; 
esac 

# Create an anchor that links back to this same script,
# except with a new QUERY_STRING equal to N. 
# Put the anchor into the web page, so the user can 
# employ it to refresh the display. 
echo "<A HREF=\"http://$SERVER_NAME$SCRIPT_NAME?$N\">"
echo "Click here to refresh the page.</A></HTML>"

Run the CGI script [http://pollux.csustan.edu/cgi-bin/counter].
This example CGI script is simple. However it illustrates that there can be a continuing "conversation" between the client and the dynamic document program.
The client can communicate with the program by clicking on a link that the program has placed in the document.
Clicking on the link causes the CGI program to execute again, using a specific QUERY_STRING as an input. One can write a CGI program to put many links within a document, each with its own associated QUERY_STRING.
The program communicates with the client by generating a new document according to the directions indicated in the QUERY_STRING, and transmitting it to the client for display.

36.12 Forms And Interaction
- The technology used in HTML forms is very similar to the idea of the CGI script in the previous section (36.11).
36.13 Server-Side Scripting Technologies
- Server-side scripting technologies such as Active Server Pages (ASP), Java Server Pages (JSP), PHP: Hypertext Preprocessor (PHP) and ColdFusion speed up the generation of new dynamic pages through the use of interpreters on the server that work with document templates containing HTML and embedded scripting information.
- Units of the scripting info are in effect little scripts that determine parts of the document.
- An interpreter processes the template. It just copies the parts that are HTML but it 'executes the little scripts' to produce the parts of the document that are variable.
- This is faster than generating the whole document with a CGI program.
36.14 Summary