The current version of CGI.pm is available at
This will copy CGI.pm to your perl library directory for use by all perl scripts. You probably must be root to do this. Now you can load the CGI routines in your Perl scripts with the line:
If you don't have sufficient privileges to install CGI.pm in the Perl library directory, you can put CGI.pm into some convenient spot, such as your home directory, or in cgi-bin itself and prefix all Perl scripts that call it with something along the lines of the following preamble:
If you are using a version of perl earlier than 5.002 (such as NT perl), use this instead:
The CGI distribution also comes with a cute module called CGI::Carp. It redefines the die(), warn(), confess() and croak() error routines so that they write nicely formatted error messages into the server's error log (or to the output stream of your choice). This avoids long hours of groping through the error and access logs, trying to figure out which CGI script is generating error messages. If you choose, you can even have fatal error messages echoed to the browser to avoid the annoying and uninformative ``Server Error'' message.
This will parse the input (from both POST and GET methods) and store it into a perl5 object called $query.
If you provide a file handle to the new() method, it will read parameters from the file (or STDIN, or whatever). The file can be in any of the forms describing below under debugging (i.e. a series of newline delimited TAG=VALUE pairs will work). Conveniently, this type of file is created by the save() method (see below). Multiple records can be saved and restored.
Perl purists will be pleased to know that this syntax accepts references to file handles, or even references to filehandle globs, which is the ``official'' way to pass a filehandle:
You can also initialize the query object from an associative array reference:
or from a properly formatted, URL-escaped query string:
To create an empty query, initialize it from an empty string or hash:
If the script was invoked as the result of an <ISINDEX> search, the parsed keywords can be obtained as an array using the keywords() method.
If the script was invoked with a parameter list (e.g. ``name1=value1&name2=value2&name3=value3''), the param() method will return the parameter names as a list. If the script was invoked as an <ISINDEX> script, there will be a single parameter named 'keywords'.
NOTE: As of version 1.5, the array of parameter names returned will be in the same order as they were submitted by the browser. Usually this order is the same as the order in which the parameters are defined in the form (however, this isn't part of the spec, and so isn't guaranteed).
Pass the param() method a single argument to fetch the value of the named parameter. If the parameter is multivalued (e.g. from multiple selections in a scrolling list), you can ask to receive an array. Otherwise the method will return a single value.
This sets the value for the named parameter 'foo' to an array of values. This is one way to change the value of a field AFTER the script has been invoked once before. (Another way is with the -override parameter accepted by all methods that generate form elements.)
param() also recognizes a named parameter style of calling described in more detail later:
This adds a value or list of values to the named parameter. The values are appended to the end of the parameter if it already exists. Otherwise the parameter is created. Note that this method only recognizes the named argument calling syntax.
This creates a series of variables in the 'R' namespace. For example, $R::foo, @R:foo. For keyword lists, a variable @R::keywords will appear. If no namespace is given, this method will assume 'Q'. WARNING: don't import anything into 'main'; this is a major security risk!!!!
In older versions, this method was called import(). As of version 2.20, this name has been removed completely to avoid conflict with the built-in Perl module import operator.
This completely clears a parameter. It sometimes useful for resetting parameters that you don't want passed down between script invocations.
This clears the CGI object completely. It might be useful to ensure that all the defaults are taken when you create a fill-out form.
This will write the current state of the form to the provided filehandle. You can read it back in by providing a filehandle to the new() method. Note that the filehandle can be a file, a pipe, or whatever!
The format of the saved file is:
Both name and value are URL escaped. Multi-valued CGI parameters are represented as repeated names. A session record is delimited by a single = symbol. You can write out multiple records and read them back in with several calls to new. You can do this across several sessions by opening the file in append mode, allowing you to create primitive guest books, or to keep a history of users' queries. Here's a short example of creating multiple session records:
open (OUT,``>>test.out'') || die;
$records = 5;
foreach (0..$records) {
my $q = new CGI;
$q->param(-name=>'counter',-value=>$_);
$q->save(OUT);
}
close OUT;
# reopen for reading
open (IN,"test.out") || die;
while (!eof(IN)) {
my $q = new CGI(IN);
print $q->param('counter'),"\n";
}
The file format used for save/restore is identical to that used by the Whitehead Genome Center's data exchange format ``Boulderio'', and can be manipulated and even databased using Boulderio utilities. See http://www.genome.wi.mit.edu/genome_software/other/boulder.html
for further details.
self_url() will return a URL, that, when selected, will reinvoke this script with all its state information intact. This is most useful when you want to jump around within the document using internal anchors but you don't want to disrupt the current contents of the form(s). Something like this will do the trick.
If you don't want to get the whole query string, call the method url() to return just the URL for the script:
You can also retrieve the unprocessed query string with query_string():
OLD VERSION require ``cgi-lib.pl''; &ReadParse; print ``The value of the antique is $in{antique}.\n'';
NEW VERSION use CGI; CGI::ReadParse print ``The value of the antique is $in{antique}.\n'';
CGI.pm's ReadParse() routine creates a tied variable named %in, which can be accessed to obtain the query variables. Like ReadParse, you can also provide your own variable. Infrequently used features of ReadParse, such as the creation of @in and $in variables, are not supported.
Once you use ReadParse, you can retrieve the query object itself this way:
This allows you to start using the more interesting features of CGI.pm without rewriting your old scripts from scratch.
The advantages of this style are that you don't have to remember the exact order of the arguments, and if you leave out a parameter, in most cases it will default to some reasonable value. If you provide a parameter that the method doesn't recognize, it will usually do something useful with it, such as incorporating it into the HTML form tag. For example if Netscape decides next week to add a new JUSTIFICATION parameter to the text field tags, you can start using the feature without waiting for a new version of CGI.pm:
This will result in an HTML tag that looks like this:
Parameter names are case insensitive: you can use -name, or -Name or -NAME. You don't have to use the hyphen if you don't want to. After creating a CGI object, call the use_named_parameters() method with a nonzero value. This will tell CGI.pm that you intend to use named parameters exclusively:
Actually, CGI.pm only looks for a hyphen in the first parameter. So you can leave it off subsequent parameters if you like. Something to be wary of is the potential that a string constant like ``values'' will collide with a keyword (and in fact it does!) While Perl usually figures out when you're referring to a function and when you're referring to a string, you probably should put quotation marks around all string constants just to play it safe.
header() returns the Content-type: header. You can provide your own MIME type if you choose, otherwise it defaults to text/html. An optional second parameter specifies the status code and a human-readable message. For example, you can specify 204, ``No response'' to create a script that tells the browser to do nothing at all. If you want to add additional fields to the header, just tack them on to the end:
The last example shows the named argument style for passing arguments to the CGI methods using named parameters. Recognized parameters are -type, -status, -expires, and -cookie. Any other parameters will be stripped of their initial hyphens and turned into header fields, allowing you to specify any HTTP header you desire.
Most browsers will not cache the output from CGI scripts. Every time the browser reloads the page, the script is invoked anew. You can change this behavior with the -expires parameter. When you specify an absolute or relative expiration interval with this parameter, some browsers and proxy servers will cache the script's output until the indicated expiration date. The following forms are all valid for the -expires field:
(CGI::expires() is the static function call used internally that turns relative time intervals into HTTP dates. You can call it directly if you wish.)
The -cookie parameter generates a header that tells the browser to provide a ``magic cookie'' during all subsequent transactions with your script. Netscape cookies have a special format that includes interesting attributes such as expiration time. Use the cookie() method to create and retrieve session cookies.
The -nph parameter, if set to a true value, will issue the correct headers to work with a NPH (no-parse-header) script. This is important to use with certain servers, such as Microsoft Internet Explorer, which expect all their scripts to be NPH.
redirects the browser elsewhere. If you use redirection like this, you should not print out a header as well. As of version 2.0, we produce both the unofficial Location: header and the official URI: header. This should satisfy most servers and browsers.
One hint I can offer is that relative links may not work correctly when you generate a redirection to another document on your site. This is due to a well-intentioned optimization that some servers use. The solution to this is to use the full URL (including the http: part) of the document you are redirecting to.
You can use named parameters:
The -nph parameter, if set to a true value, will issue the correct headers to work with a NPH (no-parse-header) script. This is important to use with certain servers, such as Microsoft Internet Explorer, which expect all their scripts to be NPH.
This will return a canned HTML header and the opening <BODY> tag. All parameters are optional. In the named parameter form, recognized parameters are -title, -author, -base, -xbase and -target (see below for the explanation). Any additional parameters you provide, such as the Netscape unofficial BGCOLOR attribute, are added to the <BODY> tag.
The argument -xbase allows you to provide an HREF for the <BASE> tag different from the current location, as in
All relative links will be interpreted relative to this tag.
The argument -target allows you to provide a default target frame for all the links and fill-out forms on the page. See the Netscape documentation on frames for details of how to manipulate this.
All relative links will be interpreted relative to this tag. You add arbitrary meta information to the header with the -meta argument. This argument expects a reference to an associative array containing name/value pairs of meta information. These will be turned into a series of header <META> tags that look something like this:
There is no support for the HTTP-EQUIV type of <META> tag. This is because you can modify the HTTP header directly with the header() method. For example, if you want to send the Refresh: header, do it in the header() method:
The -style tag is used to incorporate cascading stylesheets into your code. See the section on CASCADING STYLESHEETS for more information.
You can place other arbitrary HTML elements to the <HEAD> section with the -head tag. For example, to place the rarely-used <LINK> element in the head section, use this:
To incorporate multiple HTML elements into the <HEAD> section, just pass an array reference:
JAVASCRIPTING: The -script, -noScript, -onLoad and -onUnload parameters are used to add Netscape JavaScript calls to your pages. -script should point to a block of text containing JavaScript function definitions. This block will be placed within a <SCRIPT> block inside the HTML (not HTTP) header. The block is placed in the header in order to give your page a fighting chance of having all its JavaScript functions in place even if the user presses the stop button before the page has loaded completely. CGI.pm attempts to format the script in such a way that JavaScript-naive browsers will not choke on the code: unfortunately there are some browsers, such as Chimera for Unix, that get confused by it nevertheless.
The -onLoad and -onUnload parameters point to fragments of JavaScript code to execute when the page is respectively opened and closed by the browser. Usually these parameters are calls to functions defined in the -script field:
$query = new CGI;
print $query->header;
$JSCRIPT=<<END;
// Ask a silly question
function riddle_me_this() {
var r = prompt(``What walks on four legs in the morning, '' +
``two legs in the afternoon, '' +
``and three legs in the evening?'');
response(r);
}
// Get a silly answer
function response(answer) {
if (answer == ``man'')
alert(``Right you are!'');
else
alert(``Wrong! Guess again.'');
}
END
print $query->start_html(-title=>'The Riddle of the Sphinx',
-script=>$JSCRIPT);
Use the -noScript parameter to pass some HTML text that will be displayed on browsers that do not have JavaScript (or browsers where JavaScript is turned off).
Netscape 3.0 recognizes several attributes of the <SCRIPT> tag, including LANGUAGE and SRC. The latter is particularly interesting, as it allows you to keep the JavaScript code in a file or CGI script rather than cluttering up each page with the source. To use these attributes pass a HASH reference in the -script parameter containing one or more of -language, -src, or -code:
See
for more information about JavaScript.
The old-style positional parameters are as follows:
This ends an HTML document by printing the </BODY></HTML> tags.
Another note The default values that you specify for the forms are only used the first time the script is invoked (when there is no query string). On subsequent invocations of the script (when there is a query string), the former values are used even if they are blank.
If you want to change the value of a field from its previous value, you have two choices:
(1) call the param() method to set it.
(2) use the -override (alias -force) parameter (a new feature in version 2.15). This forces the default value to be used, regardless of the previous value:
Yet another note By default, the text and labels of form elements are escaped according to HTML rules. This means that you can safely use ``<CLICK ME>'' as the label for a button. However, it also interferes with your ability to incorporate special HTML character sequences, such as Á, into your fields. If you wish to turn off automatic escaping, call the autoEscape() method with a false value immediately after creating the CGI object:
Prints out an <ISINDEX> tag. Not very exciting. The parameter -action specifies the URL of the script to process the query. The default is to process the query with the current script.
startform() will return a <FORM> tag with the optional method, action and form encoding that you specify. The defaults are: method: POST action: this script encoding: application/x-www-form-urlencoded
endform() returns the closing </FORM> tag.
Startform()'s encoding method tells the browser how to package the various fields of the form before sending the form to the server. Two values are possible:
Forms that use this type of encoding are not easily interpreted by CGI scripts unless they use CGI.pm or another library designed to handle them.
JAVASCRIPTING: The -name and -onSubmit parameters are provided for use with JavaScript. The -name parameter gives the form a name so that it can be identified and manipulated by JavaScript functions. -onSubmit should point to a JavaScript function that will be executed just before the form is submitted to your server. You can use this opportunity to check the contents of the form for consistency and completeness. If you find something wrong, you can put up an alert box or maybe fix things up yourself. You can abort the submission by returning false from this function.
Usually the bulk of JavaScript functions are defined in a <SCRIPT> block in the HTML header and -onSubmit points to one of these function call. See start_html() for details.
textfield() will return a text input field.
If you want to reset it from its initial value after the script has been called once, you can do so like this:
NEW AS OF VERSION 2.15: If you don't want the field to take on its previous value, you can force its current value by using the -override (alias -force) parameter:
JAVASCRIPTING: You can also provide -onChange, -onFocus, -onBlur and -onSelect parameters to register JavaScript event handlers. The onChange handler will be called whenever the user changes the contents of the text field. You can do text validation if you like. onFocus and onBlur are called respectively when the insertion point moves into and out of the text field. onSelect is called when the user changes the portion of the text that is selected.
textarea() is just like textfield, but it allows you to specify rows and columns for a multiline text entry box. You can provide a starting value for the field, which can be long and contain multiple lines.
JAVASCRIPTING: The -onChange, -onFocus, -onBlur and -onSelect parameters are recognized. See textfield().
password_field() is identical to textfield(), except that its contents will be starred out on the web page.
JAVASCRIPTING: The -onChange, -onFocus, -onBlur and -onSelect parameters are recognized. See textfield().
filefield() will return a file upload field for Netscape 2.0 browsers.
In order to take full advantage of this I
The beta2 version of Netscape 2.0 currently doesn't pay any attention
to this field, and so the starting value will always be blank. Worse,
the field loses its ``sticky'' behavior and forgets its previous
contents. The starting value field is called for in the HTML
specification, however, and possibly later versions of Netscape will
honor it.
In Netscape Gold, the filename that gets returned is the full local filename
on the remote user's machine. If the remote user is on a Unix
machine, the filename will follow Unix conventions:
On an MS-DOS/Windows and OS/2 machines, the filename will follow DOS conventions:
On a Macintosh machine, the filename will follow Mac conventions:
The filename returned is also a file handle. You can read the contents
of the file using standard Perl file reading calls:
When a file is uploaded the browser usually sends along some
information along with it in the format of headers. The information
usually includes the MIME content type. Future browsers may send
other information as well (such as modification date and size). To
retrieve this information, call uploadInfo(). It returns a reference to
an associative array containing all the document headers.
If you are using a machine that recognizes ``text'' and ``binary'' data
modes, be sure to understand when and how to use them (see the Camel book).
Otherwise you may find that binary files are corrupted during file uploads.
JAVASCRIPTING: The -onChange, -onFocus, -onBlur
and -onSelect parameters are recognized. See textfield()
for details.
popup_menu() creates a menu.
JAVASCRIPTING: popup_menu() recognizes the following event handlers:
-onChange, -onFocus, and -onBlur. See the textfield()
section for details on when these handlers are called.
scrolling_list() creates a scrolling list.
When this form is processed, all selected list items will be returned as
a list under the parameter name 'list_name'. The values of the
selected items can be retrieved with:
checkbox_group() creates a list of checkboxes that are related
by the same name.
To include row and column headings in the returned table, you
can use the -rowheader and -colheader parameters. Both
of these accept a pointer to an array of headings to use.
The headings are just decorative. They don't reorganize the
interpretation of the checkboxes -- they're still a single named
unit.
The value returned by checkbox_group() is actually an array of button
elements. You can capture them and use them within tables, lists,
or in other creative ways:
JAVASCRIPTING: checkbox_group() recognizes the -onClick
parameter. This specifies a JavaScript code fragment or
function call to be executed every time the user clicks on
any of the buttons in the group. You can retrieve the identity
of the particular button clicked on using the ``this'' variable.
checkbox() is used to create an isolated checkbox that isn't logically
related to any others.
JAVASCRIPTING: checkbox() recognizes the -onClick
parameter. See checkbox_group() for further details.
radio_group() creates a set of logically-related radio buttons
(turning one member of the group on turns the others off)
To include row and column headings in the returned table, you
can use the -rowheader and -colheader parameters. Both
of these accept a pointer to an array of headings to use.
The headings are just decorative. They don't reorganize the
interpetation of the radio buttons -- they're still a single named
unit.
The value returned by radio_group() is actually an array of button
elements. You can capture them and use them within tables, lists,
or in other creative ways:
submit() will create the query submission button. Every form
should have one of these.
JAVASCRIPTING: radio_group() recognizes the -onClick
parameter. See checkbox_group() for further details.
reset() creates the ``reset'' button. Note that it restores the
form to its value from the last time the script was called,
NOT necessarily to the defaults.
defaults() creates a button that, when invoked, will cause the
form to be completely reset to its defaults, wiping out all the
changes the user ever made.
hidden() produces a text field that can't be seen by the user. It
is useful for passing state variable information from one invocation
of the script to the next.
Note, that just like all the other form elements, the value of a
hidden field is ``sticky''. If you want to replace a hidden field with
some other values after the script has been called once you'll have to
do it manually:
image_button() produces a clickable image. When it's clicked on the
position of the click is returned to your script as ``button_name.x''
and ``button_name.y'', where ``button_name'' is the name you've assigned
to it.
JAVASCRIPTING: image_button() recognizes the -onClick
parameter. See checkbox_group() for further details.
button() produces a button that is compatible with Netscape 2.0's
JavaScript. When it's pressed the fragment of JavaScript code
pointed to by the -onClick parameter will be executed. On
non-Netscape browsers this form element will probably not even
display.
A cookie is a name=value pair much like the named parameters in a CGI
query string. CGI scripts create one or more cookies and send
them to the browser in the HTTP header. The browser maintains a list
of cookies that belong to a particular Web server, and returns them
to the CGI script during subsequent interactions.
In addition to the required name=value pair, each cookie has several
optional attributes:
cookie() creates a new cookie. Its parameters include:
To create multiple cookies, give header() an array reference:
To retrieve a cookie, request it by name by calling cookie()
method without the -value parameter:
The cookie and CGI namespaces are separate. If you have a parameter
named 'answers' and a cookie named 'answers', the values retrieved by
param() and cookie() are independent of each other. However, it's
simple to turn a CGI parameter into a cookie, and vice-versa:
See the cookie.cgi example script for some ideas on how to use
cookies effectively.
NOTE: There appear to be some (undocumented) restrictions on
Netscape cookies. In Netscape 2.01, at least, I haven't been able to
set more than three cookies at a time. There may also be limits on
the length of cookies. If you need to store a lot of information,
it's probably better to create a unique session ID, store it in a
cookie, and use the session ID to locate an external file/database
saved on the server's side of the connection.
There is no specific support for creating <FRAMESET> sections
in CGI.pm, but the HTML is very simple to write. See the frame
documentation in Netscape's home pages for details
This will tell Netscape to load the output of your script into the
frame named ``ResultsWindow''. If a frame of that name doesn't
already exist, Netscape will pop up a new window and load your
script's document into that. There are a number of magic names
that you can use for targets. See the frame documents on Netscape's
home pages for details.
When your script is reinvoked by the form, its output will be loaded
into the frame named ``ResultsWindow''. If one doesn't already exist
a new window will be created.
To refer to a style within the body of your document, add the
-class parameter to any HTML element:
Or define styles on the fly with the -style parameter:
You may also use the new span() element to apply a style to a
section of text:
Note that you must import the ``:html3'' definitions to have the
span() method available. Here's a quick and dirty example of using
CSS's. See the CSS specification at
http://www.w3.org/pub/WWW/TR/Wd-css-1.html for more information.
or this:
or this:
or this:
or even as newline-delimited parameters on standard input.
When debugging, you can use quotes and backslashes to escape
characters in the familiar shell manner, letting you place
spaces and other funny characters in your parameter=value
pairs:
Produces something that looks like:
You can pass a value of 'true' to dump() in order to get it to
print the results out as plain text, suitable for incorporating
into a <PRE> section.
As a shortcut, as of version 1.56 you can interpolate the entire CGI
object into a string and it will be replaced with the a nice HTML dump
shown above:
NOTE: The Microsoft Internet Information Server
is broken with respect to additional path information. If
you use the Perl DLL library, the IIS server will attempt to
execute the additional path information as a Perl script.
If you use the ordinary file associations mapping, the
path information will be present in the environment,
but incorrect. The best thing to do is to avoid using additional
path information in CGI scripts destined for use with IIS.
The Microsoft IIS is broken with respect to the translated
path as well.
This example shows how to use the HTML methods:
This results in the following HTML code (extra newlines have been
added for readability):
If you find the syntax for calling the HTML shortcuts awkward, you can
import them into your namespace and dispense with the object syntax
completely (see the next section for more details):
If you provide one or more string arguments, they are concatenated
together with spaces and placed between opening and closing tags:
If the first argument is an associative array reference, then the keys
and values of the associative array become the HTML tag's attributes:
You are free to use CGI.pm-style dashes in front of the attribute
names if you prefer:
Now, in addition to the standard CGI shortcuts, you've created HTML
tags named ``winkin'', ``blinkin'' and ``nod''. You can use them like this:
The listed methods will be imported into the current package; you can
call them directly without creating a CGI object first. This example
shows how to import the param() and header()
methods, and then use them directly:
You can import groups of methods by referring to a number of special
names:
If you import any of the state-maintaining CGI or form-generating
methods, a default CGI object will be created and initialized
automatically the first time you use any of the methods that require
one to be present. This includes param(), textfield(),
submit() and the like. (If you need direct access to the CGI
object, you can find it in the global variable $CGI::Q). By
importing CGI.pm methods, you can create visually elegant scripts:
Servers use a variety of conventions for designating CGI scripts as
NPH. Many Unix servers look at the beginning of the script's name for
the prefix ``nph-''. The Macintosh WebSTAR server and Microsoft's
Internet Information Server, in contrast, try to decide whether a
program is an NPH script by examining the first line of script output.
CGI.pm supports NPH scripts with a special NPH mode. When in this
mode, CGI.pm will output the necessary extra header information when
the header() and redirect() methods are
called.
The Microsoft Internet Information Server requires NPH mode. As of version
2.30, CGI.pm will automatically detect when the script is running under IIS
and put itself into this mode. You do not need to do this manually, although
it won't hurt anything if you do.
There are a number of ways to put CGI.pm into NPH mode:
Address bug reports and comments to:
lstein@genome.wi.mit.edu
Note that the code is truly contorted in order to avoid spurious
warnings when programs are run with the -w switch.
When the form is processed, you can retrieve the entered filename.by calling param().
# Copy a binary file to somewhere safe
open (OUTFILE,``>>/usr/local/web/users/feedback'');
while ($bytesread=read($filename,$buffer,1024)) {
print OUTFILE $buffer;
}
CREATING A POPUP MENU
When the form is processed, the selected value of the popup menu can.be retrieved using:
CREATING A SCROLLING LIST
JAVASCRIPTING: scrolling_list() recognizes the following event handlers:.-onChange, -onFocus, and -onBlur. See textfield() for
the description of when these handlers are called.
CREATING A GROUP OF RELATED CHECKBOXES
When the form is processed, all checked boxes will be returned as.a list under the parameter name 'group_name'. The values of the
``on'' checkboxes can be retrieved with:
CREATING A STANDALONE CHECKBOX
The value of the checkbox can be retrieved using:.
$turned_on = $query->param('checkbox_name');
CREATING A RADIO BUTTON GROUP
When the form is processed, the selected radio button can.be retrieved using:
CREATING A SUBMIT BUTTON
You can figure out which button was pressed by using different.values for each one:
CREATING A RESET BUTTON
CREATING A DEFAULT BUTTON
CREATING A HIDDEN FIELD
Fetch the value of a hidden field this way:.
$hidden_value = $query->param('hidden_name');
CREATING A CLICKABLE IMAGE BUTTON
Fetch the value of the button this way:. $x = $query->param('button_name.x');
$y = $query->param('button_name.y');
CREATING A JAVASCRIPT ACTION BUTTON
NETSCAPE COOKIES
Netscape browsers versions 1.1 and higher support a so-called
``cookie'' designed to help maintain state within a browser session.
CGI.pm has several methods that support cookies.
The interface to Netscape cookies is the cookie() method:.
$cookie = $query->cookie(-name=>'sessionID',
-value=>'xyzzy',
-expires=>'+1h',
-path=>'/cgi-bin/database',
-domain=>'.capricorn.org',
-secure=>1);
print $query->header(-cookie=>$cookie);
The cookie created by cookie() must be incorporated into the HTTP.header within the string returned by the header() method:
WORKING WITH NETSCAPE FRAMES
It's possible for CGI.pm scripts to write into several browser
panels and windows using Netscape's frame mechanism.
There are three techniques for defining new frames programmatically:
The script ``frameset.cgi'' in the examples directory shows one way to.create pages in which the fill-out form and the response live in
side-by-side frames.
LIMITED SUPPORT FOR CASCADING STYLE SHEETS
CGI.pm has limited support for HTML3's cascading style sheets (css).
To incorporate a stylesheet into your document, pass the
start_html() method a -style parameter. The value of this
parameter may be a scalar, in which case it is incorporated directly
into a <STYLE> section, or it may be a hash reference. In the latter
case you should provide the hash with one or more of -src or
-code. -src points to a URL where an externally-defined
stylesheet can be found. -code points to a scalar value to be
incorporated into a <STYLE> section. Style definitions in -code
override similarly-named ones in -src, hence the name ``cascading.''
#here's a stylesheet incorporated directly into the page
$newStyle=<<END;
<!--
P.Tip {
margin-right: 50pt;
margin-left: 50pt;
color: red;
}
P.Alert {
font-size: 30pt;
font-family: sans-serif;
color: red;
}
-->
END
print header();
print start_html( -title=>'CGI with Style',
-style=>{-src=>'http://www.capricorn.com/style/st1.css',
-code=>$newStyle}
);
print h1('CGI with Style'),
p({-class=>'Tip'},
``Better read the cascading style sheet spec before playing with this!''),
span({-style=>'color: magenta'},
``Look Mom, no hands!'',
p(),
``Whooo wee!''
);
print end_html;
DEBUGGING
If you are running the script
from the command line or in the perl debugger, you can pass the script
a list of keywords or parameter=value pairs on the command line or
from standard input (you don't have to worry about tricking your
script into reading from environment variables).
You can pass keywords like this:
DUMPING OUT ALL THE NAME/VALUE PAIRS
The dump() method produces a string consisting of all the query's
name/value pairs formatted nicely as a nested list. This is useful
for debugging purposes:
FETCHING ENVIRONMENT VARIABLES
Some of the more useful environment variables can be fetched
through this interface. The methods are as follows:
.
CREATING HTML ELEMENTS:
In addition to its shortcuts for creating form elements, CGI.pm
defines general HTML shortcut methods as well. HTML shortcuts are
named after a single HTML element and return a fragment of HTML text
that you can then print or manipulate as you like.
PROVIDING ARGUMENTS TO HTML SHORTCUTS
The HTML methods will accept zero, one or multiple arguments. If you
provide no arguments, you get a single tag:
Generating new HTML tags
Since no mere mortal can keep up with Netscape and Microsoft as they
battle it out for control of HTML, the code that generates HTML tags
is general and extensible. You can create new HTML tags freely just
by referring to them on the import line:
IMPORTING CGI METHOD CALLS INTO YOUR NAME SPACE
As a convenience, you can import most of the CGI method calls directly
into your name space. The syntax for doing this is:
Note that in the interests of execution speed CGI.pm does not use.the standard Exporter syntax for specifying load symbols. This may
change in the future.
USING NPH SCRIPTS
NPH, or ``no-parsed-header'', scripts bypass the server completely by
sending the complete HTTP header directly to the browser. This has
slight performance benefits, but is of most use for taking advantage
of HTTP extensions that are not directly supported by your server,
such as server push and PICS headers.
.
AUTHOR INFORMATION
Copyright 1995,1996, Lincoln D. Stein. All rights reserved. It may
be used and modified freely, but I do request that this copyright
notice remain attached to the file. You may modify this module as you
wish, but if you redistribute a modified version, please attach a note
listing the modifications you have made.
CREDITS
Thanks very much to:
.
A COMPLETE EXAMPLE OF A SIMPLE FORM-BASED SCRIPT
foreach $key ($query->param) {
print ``<STRONG>$key</STRONG> -> '';
@values = $query->param($key);
print join(``, '',@values),``<BR>\n'';
}
}
sub print_tail {
print <<END;
<HR>
<ADDRESS>Lincoln D. Stein</ADDRESS><BR>
<A HREF=``/''>Home Page</A>
END
}
BUGS
This module has grown large and monolithic. Furthermore it's doing many
things, such as handling URLs, parsing CGI input, writing HTML, etc., that
are also done in the LWP modules. It should be discarded in favor of
the CGI::* modules, but somehow I continue to work on it.
SEE ALSO
CGI::Carp, URI::URL, CGI::Request, CGI::MiniSvr,
CGI::Base, CGI::Form, CGI::Apache, CGI::Switch,
CGI::Push, CGI::Fast