Header Options for the Server and Browser

Using different content types when printing the output of a script

text/plain: If something is wrong with the HTML code, it is possible to send the script as text/plain. Then you will see all of the HTML code displayed on the screen. This may be helpful for debugging purposes. Also, it is possible to print the content of non-HTML files by sending this content type.
text/html: This allows the script to create HTML documents 'on the fly'.
multipart/x-mixed-replace, pages 566-569 of the text: This type is used for server push. It needs to be used in an nph- script. The script sends multiple pages, each separated by a boundary string of your choosing.

Using the enctype field in a form

multipart/form-data, pages 553-556 of the text

This type is used to upload a file from the browser to the server. Use the <form> tag with the format

<form method=post enctype="multipart/form-data">

This will send the name/value pairs of the form in a different format, and will send the contents of the file. With this format, the browser is sending the data to the server in a different format, and changes the enctype field to let the server know.

Try this form for uploading a file, test_stdin.html, and you will see how the data is sent to the server.

Browser Pull

Refresh, pages 565-566 of the text
- Include a refresh statement in order for the browser to re-read the page after the specified number of seconds.
- Include the optional field URL= to indicate that a different page should be loaded, or to send paramters when the current page is reloaded. If URL is omitted, then the current page is reloaded with its current paramters.
```
Refresh: 5
Content-type: text/html

or

Refresh: 5; URL=http:/somewhere/else
Content-type: text/html

or

Refresh: 2; URL="current.pl?parm1=val1&parm2=val2"
Content-type: text/html
```
The same effect can be achieved by encoding a refresh statement into the head section of the browser. The same options as above are available, but it can be implemented without using a script. Of course, a script could be written that prints the HTML code for the refresh. Not covered in the text.
- Inlcude a <meta http-equiv="Refresh" Content="5"> tag in the <head> section of the HTML document.
- There is an optional URL field, that has the same effect as outlined above. The last option only makes sense if the HTML document is being created by a script entitled current.pl.
```
<head>
<meta http-equiv="refresh" content="5">

<head>
<meta http-equiv="refresh" content="5; URL=http://somewhere/else">

<head>
<meta http-equiv="refresh" content="2; URL=current.pl?parm1=val1&parm2=val2">
```

Server Push

Non-Parsed-Header, page 566-568 of the text.
- Keeps connection open
- MIME type is multipart/x-mixed-replace
- Document contains multiple pages
- Pages separated by a boundary line of your choosing. Just be sure it isn't a line that would normally appear in the document.
- This is an example of the response header that your script should send
```
Status: 200 OK
Server: Apache/1.2.5, Any text
Content-type: multipart/x-mixed-replace; boundary=-------anything-at-all
```
- Then your script may send as many different pages as it wants. Each page should be a complete page, including the Content-type line. Preface each page with the boundary line
```
-------anything-at-all
Content-type: text/html

(rest of page)
```
- Be sure to unbuffer the output by palcing the following command before any print statements in your PERL script. (in case you can't read it: Dollar-sign Vertical-bar Equal-sign Number-one Semi-colon)
```
$|=1;
```
- Also, you must disable the server's control over its internal buffer. Usually, the server will accumulate a lot of data, before sending it to the browser, this makes most efficient use of the connection. However, if the page you are sending is small, and the size of the server's buffer is large, then each page won't be sent separately. Solve this problem by sending a "no parse header" (NPH) script. This type of script by-passes the server's buffer, and sends all data directly to the browser.
  - Your script must print the Status field in the response header
  - Also, send the Server field, just to be nice
  - For an Apache server, be sure that the name of the script starts with nph- (not nph_, NPH-, etc)

Cookies, page 536-541 of the text

A cookie is a way to have the browser store information about the connection that a script can use. It is implemented by the Set-cookie: field in the response header.
- Maintained by the browser
- Can be associated with a particular file or path
- Can be assigned an expiration date. By default, they expire when the user quits the browser.
Setting cookies
- A cookie for the current server, that expires when the user quits the browser
```
Set-cookie: color=red
Content-type: text/html
```
- A cookie for the current server, that has an expiration data.
```
Set-cookie: color=red; expires=Friday, 03-April-98 13:34:20 GMT
Content-type: text/html
```
- A cookie that is for only a particular path
```
Set-cookie: color=red; path=/scripts
Content-type: text/html
```
- A cookie for a particular file
```
Set-cookie: color=red; path=/scripts/foobar.pl
Content-type: text/html
```
- I have included a function in parse-lib.pl that will generate the current time in GMT format. The function has an optional parameter that will allow you to create a date in the future, by passing the number of seconds in the future.
```
#current time in the format that Set-cookie wants
$now = &time_gmt;

#30 seconds in the future in the format that Set-cookie wants
$future = &time_gmt(30);
```
Retrieving cookies
- I have created a function in parse-lib that will retrieve the cookies into an associative array. After this call, the script will have an associative array, %cookie, that contains all the name value pairs of cookies that were sent. If two of the same cookie are received, the values will be joined into one entry using the $; symbol. Call it as
```
require '/home/scsfac/downey/scripts/parse-lib.pl'
%cookies = &get_cookie;
```