| Table of Contents | Previous Next |
16.3 CGI applications with ASPAlthough the Request object of ASP has only one function, it contains a number of collections, dedicated for CGI applications. The concept of a collection is similar to that of an array. It is a place to store strings, numbers, objects, and other variables with values. Unlike arrays, you can access the data of a collection through either indices or names. The first collection of the Request object that we are going to introduce is the ServerVariables collection. 16.3.1 Using server variablesServer variables are environment features from the server providing critical information if you want to develop server-specific applications. Some frequently used server variables are:
The Request object from the ASP package contains a collection called ServerVariables (see Table 16.1) that can be directly used to get the data stored in a particular variable. For example, to get the version of the gateway interface, you can use the following command in your ASP page:
Request.ServerVariables("GATEWAY_INTERFACE")
Since ServerVariables is implemented as a collection in ASP, you can access the data through names referencing. To get the server variables above, you can use the following ASP page:
Example: ex16-08.asp - Some Server Variables
1: <%@ LANGUAGE="JScript" %>
2: <?xml version="1.0" encoding="iso-88591"?>
3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
4: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
5: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
6: <head><title> Server Variables - ex1608.asp</title></head>
7: <body style="background:#000088;font-family:arial;color:#ffff00">
8: <div style="font-size:22pt;text-align:center;color:#00ff00">
9: Some Server Variables</div>
10: <table style="font-size:14pt" cellspacing="15" align="center" >
11: <tr><th>Variable</th><th>Value</th></tr>
12: <%
13: Response.Write('<tr><td>GATEWAY_INTERFACE</td><td>' +
14: Request.ServerVariables("GATEWAY_INTERFACE") + '</td></tr>')
15: Response.Write('<tr><td>HTTP_HOST</td><td>' +
16: Request.ServerVariables("HTTP_HOST") + '</td></tr>')
17: Response.Write('<tr><td>QUERY_STRING</td><td>' +
18: Request.ServerVariables("QUERY_STRING") + '</td></tr>')
19: Response.Write('<tr><td>REQUEST_METHOD</td><td>' +
20: Request.ServerVariables("REQUEST_METHOD") + '</td></tr>')
21: Response.Write('<tr><td>SERVER_NAME</td><td>' +
22: Request.ServerVariables("SERVER_NAME") + '</td></tr>')
23: Response.Write('<tr><td>SERVER_PROTOCOL</td><td>' +
24: Request.ServerVariables("SERVER_PROTOCOL") + '</td></tr>')
25: Response.Write('<tr><td>SERVER_SOFTWARE</td><td>' +
26: Request.ServerVariables("SERVER_SOFTWARE") + '</td></tr>')
27: Response.Write('<tr><td>URL</td><td>' +
28: Request.ServerVariables("URL") + '</td></tr>')
29: %>
30: </table>
31: </body>
32: </html>
In this example, the ASP section is defined in lines 1229. This section contains direct function calls to Request.ServerVariables() for each of the server variables above. After all the statements in the scripting section are processed, a complete XHTML page is returned back to the browser. From the browser's point of view, the returned page is a pure XHTML page. A screen shot of this example on Windows XP with IIS using the IE6 browser is shown in Fig. 16.7. Figure 16.7. ex16-08.asp
If you need to develop an ASP page dedicated to server software such as Microsoft IIS 4.0, you may need to perform detection on the server variable SERVER_SOFTWARE. There are more than 40 server variables available from the ServerVariables collection. An iteration method is used to find them all later in this section. Some frequently used server variables are listed in Table 16.2.
16.3.2 Passing form data to ASP pages with QueryStringMost of the server and CGI applications are related to forms. Therefore passing form information to ASP pages is important before any real application can be constructed. The Request object of ASP provides two collections, namely, QueryString and Form dedicated to retrieving form data from ASP pages. The first collection QueryString is responsible for obtaining form data when a get method is used. To understand how QueryString works, let's consider the following XHTML form document:
Example: ex16-09.htm - Passing Form Data To ASP With QueryString
1: <?xml version="1.0" encoding="iso-88591"?>
2: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
3: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
4: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
5: <head><title> Passing Form Data To ASP - ex1609.htm</title></head>
6: <style>
7: .butSt{background:#aaffaa;width:250px;
8: font-family:arial;font-weight:bold;font-size:16pt;color:#880000}
9: .txtSt{font-family:arial;font-weight:bold;font-size:16pt;color:#ffff00}
10: </style>
11: <body style="font-family:arial;font-weight:bold;font-size:18pt;
12: background:#000088;color:#ffff00"><br />
13: Passing Form Data To ASP With QueryString<br /><br />
14: <form name="myForm" action="ex16-09.asp" method="get">
15: <table class="txtSt">
16: <tr><td>Name:</td><td>
17: <input type="text" name="name" class="butSt"></td></tr>
18: <tr><td>Email Address:</td><td>
19: <input type="text" name="email" class="butSt"></td></tr>
20: <tr><td>Telephone:</td><td>
21: <input type="text" name="phone" class="butSt"></td></tr>
22: <tr><td><input type=reset value="Clear" class="butSt"></td><td>
23: <input type=submit value="Submit" class="butSt"></td></tr>
24: </table>
25: </form>
26: </body>
27: </html>
This XHTML page contains a form with three fields, namely "name," "email," and "phone." They are all defined as text boxes in lines 17, 19, and 21 respectively. Suppose you have filled the form with data Name: Johnsmith Email Address: johnsmith@pwt-ex.com Telephone: 0189012345678 From line 14, this form uses the get method to submit the data. This means that once the Submit button is pressed, the form will activate the ASP page ex16-09.asp with the following URL request:
http://www.pwt-ex.com/ex1609.asp?name=Johnsmith&
email=johnsmith@pwt-ex.com& phone=0189012345678
The string after the question mark "?" is called the query string from the CGI. This query string contains the name/value pairs input by the user and attached at the end of the ASP page. Using ASP, the entire query string is automatically stored in the QueryString collection of the Request object. To retrieve, for example, the name, you can use the following statement:
<% Request.QuseryString("name") %>
To complete the example, the ASP page ex16-09.asp is listed below:
Example: ex16-09.asp - The ASP Page For ex16-09.htm
1: <%@ LANGUAGE="JScript" %>
2: <?xml version="1.0" encoding="iso-88591"?>
3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
4: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
5: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
6: <head><title>ASP Page: ex1609.asp </title></head>
7: <body style="font-family:arial;font-weight:bold;font-size:18pt;
8: background:#000088;color:#ffff00"><br />
9: You Have Entered The Following Data:<br /><br />
10:
11: Name = <%=Request.QueryString("name")%><br />
12: Email = <%=Request.QueryString("email")%><br />
13: Phone = <%=Request.QueryString("phone")%><br />
14: </body>
15: </html>
To extract the form data from the CGI query string, all you have to do is to call the function Request.QueryString() three times as illustrated in lines 1113. Some screen shots of this example are shown in Figs 16.816.9. Figure 16.8. ex16-09.htm
Figure 16.9. Collecting data with QueryString
You can see that the query string appears in the address bar of Fig. 16.9. In fact, any query string submitted to an ASP page in name/value format is intercepted and stored in the QueryString collection. This process pays no attention as to whether a form is used or not. For example, you can replace the entire form (lines 1425) of ex16-09.htm by one statement: <a href="http://www.pwt-ex.com/ex1609.asp?name=Johnsmith& email=johnsmith@pwt-ex.com&phone=0189012345678">Click Me</a> In this case, you don't need to complete the form in order to pass data. This statement is the so-called canned query. The main characteristic is that the name/value pairs are hardwired into the URL. When the underlined text is clicked, the entire URL is submitted to the ASP page ex16-09.asp. The query string will be captured by the QueryString collection. Therefore you have the same result as illustrated in Fig. 16.9. One popular use of canned query is to pass data automatically. For example, you can put user name and password in a query string and submit them in order to log into some sites and/or database applications. 16.3.3 Capture checkbox values with the Form collectionThe Request object also has a collection called Form to handle all form information submitted by the post method. The usage of the Form collection is similar to the QueryString collection. Suppose you have form data called email defined in the following XHTML fragment: <form name="myForm" action="ex1608.asp" method="post"> Enter Your Email Address: <input type="text" name="name"> Enter Your Name: <input type="text" name="email"> Enter Your Phone Number: <input type="text" name="phone"> <input type="submit" value="Submit"> </form> This is an XHTML form using the post method. Once the Submit button is clicked, the form data, i.e., name, email, and phone, can be accessed using the following ASP statements:
Name = <%=Request.Form("name")%>
Email = <%=Request.Form("email")%>
Phone = <%=Request.Form("phone")%>
All you have to do is to replace the keyword Request.QueryString with Request.Form for the CGI post method. The characteristics of using QueryString are as follows:
One of the main criticisms of QueryString is that you may run the risk of losing data if your Web server cannot handle long (or very long) strings. Since QueryString data appear on the address bar of browsers, some Web servers tend to restrict the size of the URL string. Any QueryString longer than the allowed length will be truncated. This may be a nasty bug for your Web applications. On the other hand, the CGI post application passes data using the HTTP request body. This means that you can send a virtually unlimited number of characters to a server. Also, by using HTTP to hide the submitted data, you have a minimum level of data security for some applications. Based on these reasons, a popular application of the Form collection is to handle data from XHTML input boxes. We will show you how to use the Form collection to capture checkbox data below. In fact, you have already encountered a number of checkbox applications in previous chapters. Together with radio and select boxes, they are a fundamental resource for building interactive Web pages. In the next example, we will show you how to control them using the ASP Form collection objects. Checkboxes are composite structures and often have multiple values. To handle structures like this, you will find that an ASP object is easier to operate. For example, if you want to use a property or function of an object, you just append the function or property name at the end of the object with a period. To demonstrate this characteristic, consider the XHTML part of the following example:
Example: ex16-10.htm - Using CheckBoxes With ASP
1: <?xml version="1.0" encoding="iso-88591"?>
2: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
3: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
4: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
5: <head><title> Using CheckBoxes With ASP - ex1610.htm</title></head>
6: <style>
7: .butSt{background:#aaffaa;width:250px;
8: font-family:arial;font-weight:bold;font-size:16pt;color:#880000}
9: .chkSt{background:#aaffaa;width:30px;height:30px;
10: font-family:arial;font-weight:bold;font-size:16pt;color:#880000}
11: .txtSt{font-family:arial;font-weight:bold;font-size:16pt;color:#ffff00}
12: </style>
13: <body style="font-family:arial;font-weight:bold;font-size:18pt;
14: background:#000088;color:#ffff00"><br />
15:
16: <form name="statForm" action="ex16-10.asp" method="post">
17: <div style="position:absolute;top:40px;left:60px;">
18: Which Operating Systems Have You Used? </div><br />
19: <div style="position:absolute;top:100px;left:100px;">
20: <input name="os" type="checkbox" value="Windows XP" class="chkSt" />
21: Windows XP<br />
22: <input name="os" type="checkbox" value="Windows 2000" class="chkSt" />
23: Windows 2000<br />
24: <input name="os" type="checkbox" value="Windows 9x" class="chkSt" />
25: Windows 9x<br />
26: <input name="os" type="checkbox" value="LINUX" class="chkSt" />
27: LINUX<br /> </div>
28: <div style="position:absolute;top:100px;left:340px;">
29: <input name="os" type="checkbox" value="Mac OS" class="chkSt" />
30: Mac OS<br />
31: <input name="os" type="checkbox" value="IRIS" class="chkSt" />
32: IRIS<br />
33: <input name="os" type="checkbox" value="Solaris" class="chkSt" />
34: Solaris<br />
35: <input name="os" type="checkbox" value="Sun OS" class="chkSt" />
36: Sun OS<br /> </div>
37: <div style="position:absolute;top:260px;left:60px;">
38: <input type="submit" value="Submit" class="butSt">
39: <input type="reset" value="Clear" class="butSt">
40: </div>
41: </form>
42: </body>
43: </html>
This is a classic form application from XHTML. Inside the form defined in lines 1641, there are four divisions. They all have position properties set up in the CCS style so that they are set in some particular location of the browser window. For example, the second division (lines 1927) is a block containing four checkboxes located at (100px, 100px) in (top, left) format. Right next to these checkboxes, another four check boxes are generated. A screen shot of this page is shown in Fig. 16.10. Figure 16.10. ex16-10.htm
Once the Submit button is pressed, the form will be sent to the ASP page below:
Example: ex16-10.asp - The ASP Page For ex16-10.htm
1: <%@ LANGUAGE="JScript" %>
2: <?xml version="1.0" encoding="iso-88591"?>
3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
4: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
5: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
6: <head><title>ex1610.asp</title></head>
7: <body style="font-family:arial;font-weight:bold;font-size:18pt;
8: background:#000088;color:#ffff00"><br />
9: <%
10: if (Request.Form("os").Count ==0)
11: {
12: Response.Write("You Have Used No Operating System Before!<br />" +
13: " I Don't Believe You!")
14: }
15: else if (Request.Form("os").Count==1)
16: {
17: Response.Write("You Only Use This Operating System?<br /> ")
18: Response.Write (Request.Form("os")(1) + "<br />")
19: Response.Write("Try to Use More.")
20: } else
21: {
22: var i
23: Response.Write("You've Used All These Operating Systems? <br /><br />")
24: for (i = 1; i <= Request.Form("os").Count; i++) {
25: Response.Write (Request.Form("os")(i) + "<BR>")
26: }
27: Response.Write("<br />" + "Very Good...")
28: }
29: %>
30: </body>
31: </html>
When the Request object is applied to Form("os"), you have an object like
Request.Form("os")
containing data from all checkboxes with name "os." To find out how much data are actually inside the object, you can use
Request.Form("os").Count
Therefore, you can use this property to construct a conditional statement in lines 1014 to detect if no checkbox has been checked. Furthermore, if the first check box is checked by a user, the property
Request.Form("os")(1)
will return the value defined by the first checkbox. This feature can be used to construct a for-loop in lines 2426 to display all the operating systems picked by the user. A screen shot is shown in Fig. 16.11. Figure 16.11. ex16-10.asp
Count is a method available for most ASP collections. Therefore the QueryString collection can also have this feature. Up to now, we have only used a collection in the same way as an array. In fact, a collection is more powerful than a traditional array. To understand more about the ASP collection structure, an iterating method is introduced to display all name/value pairs stored in ASP collections. 16.3.4 Using iteration methods on ASP collectionsIf you take a look at ASP objects (Table 16.1), you will find that most of them support a data type called collection. Collection is an important structure for CGI programming using ASP and hence essential for Web applications. In fact, the ServerVariables of the Request object is a collection in ASP containing a large number of variables. A collection is a place to store strings, numbers, objects, and other variables with values. The concept of a collection is similar to that of an array and you can retrieve data from it. Unlike an array, the position of a collection may vary from time to time when the collection is modified. Also, ASP provides a Count property for a collection. The statement Request.ServerVariables.Count returns the total number of items in the ServerVariables collection. You can access elements in a collection by its name or its position (or index). For example, the following two statements return the same results:
Request.ServerVariables("REQUEST_METHOD")
Request.ServerVariables(35)
Using position, you can loop through all server variables. For example, the following JScript for-loop can display all data in the ServerVariables collection:
<%
endNo = Request.ServerVariables.Count
for (ii=0;ii<endNo;ii++)
{
Response.Write(Request.ServerVariables(ii))
}
%>
Basically, a collection is a structure that can provide name/value referencing. If your ASP scripting language supports foreach statements, you can use it to iterate through a collection to get all name/value pairs. For example, you can use the following VBScript fragment to find name/value pairs of server variables:
<%
for each key in Request.ServerVariables
Response.Write key & " = "
if Request.ServerVariables(key) = "" then
Response.Write " "
else
Response.Write Request.ServerVariables(key) & "<br />"
end if
next
%>
In this case, the variable key contains the server variable names one by one and the function Request.ServerVariables(key) returns the data associated with key. If you are using JScript, you can use the Enumerator object to iterate through an ASP collection. Basically, the Enumerator object provides the following three functions to move around a collection:
For example, the JScript fragment below demonstrates how to use this Enumerator object:
enObj = new Enumerator(Request.ServerVariables)
while (!enObj.atEnd(enObj))
{
key = enObj.item()
Response.Write( key +' = ' +
Request.ServerVariables(key) + ' <br />')
enObj.moveNext()
}
The first line is to create an object using the Enumerator() function on a collection. This new object enObj contains all data from ServerVaraibles. The while-loop, basically, is a detector to see whether the current item is the end item. If not, the name is output to a variable called key. Since the variable key represents the name of the server variable, it can be used to make the call Request.Server Variables(key) to obtain the data. A call to enObj.moveNext() will move to the next item. When the while-loop is completed, all the name/value pairs are displayed. To see this example fragment into action, consider the ASP page below:
Example: ex16-11.asp - Display All Server Variables
1: <%@ LANGUAGE="JScript" %>
2: <?xml version="1.0" encoding="iso-88591"?>
3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
4: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
5: <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
6: <head><title> Display All Server Variables - ex1611.asp</title><head>
7: <body style="background:#000088;font-family:arial;color:#ffff00">
8: <div style="font-size:22pt;text-align:center;color:#00ff00">
9: Display All Server Variables</div>
10: <table style="font-size:14pt" align="center" border="1">
11: <tr><th>Variable</th><th>Value</th></tr>
12: <% var enObj, ii
13: enObj = new Enumerator(Request.ServerVariables)
14: while (!enObj.atEnd(enObj))
15: {
16: ii = enObj.item()
17: Response.Write('<tr><td>' + ii + '</td><td>' +
18: Request.ServerVariables(ii) + '</td></tr>')
19: enObj.moveNext()
20: }
21: %>
22: </table>
23: </body>
24: </html>
This ASP page iterates through the server variable collection and displays all name/value pairs as a table. The scripting block defined in lines 1221 is inline with the JScript fragment mentioned above. All server variables including names and data are displayed as a table. This example can also be applied to all CGI applications. For example, instead of a QueryString collection, you can get the submitted results of example ex16-09.htm by the post method as follows:
This new example uses the CGI post method to call the ASP program ex16-12.asp. The ASP collection Request.Form() contains all the CGI name/value pairs submitted by a form using the post method. To get and display all submitted name/value pairs, you can develop the ASP program ex16-12.asp by replacing the ASP statements in lines 822 in ex16-11.asp by
Example: ex16-12.asp - Iterating All Name/Value Pairs For ASP Collection
8: <div style="font-size:22pt;text-align:center;color:#00ff00">
9: CGI Name/Value Pairs <div><br />
10: <table style="font-size:14pt" align="center" border="1">
11: <tr><th>Variable</th><th>Value</th></tr>
12: <% var var enObj,ii
13: enObj = new Enumerator(Request.Form)
14: while (!enObj.atEnd(enObj))
15: {
16: ii = enObj.item()
17: Response.Write('<tr><td>' + ii + '</td><td>' +
18: Request.Form(ii) + '</td></tr>')
19: enObj.moveNext()
20: }
21: %>
22: </table>
This example is a general method to capture all data submitted by a CGI post method. In fact, we simply replaced one statement, i.e., to change the ServerVariables collection to Request.Form collection. A screen shot to display all submitted data from ex16-12.htm is shown in Fig. 16.12. Figure 16.12. ex16-12.asp
Iteration methods can be applied to any ASP collections and therefore are a general technique for all ASP objects with collections. Since QueryString is an ASP collection for the CGI get method, you can use an iteration method to get all CGI name/value pairs related to the query string. Basically, all you have to do is to replace the Request.Form with Request.QueryString. We have introduced a number of CGI applications in the last two chapters. You can try applying ASP techniques to these CGI applications to achieve the same or similar results. Instead of the Perl script page, you now have ASP page support. Apart from the internal objects, the ASP package for PWS and IIS also included some server-side ActiveX components. These components provide objects that greatly enhance the capability of ASP on Web applications. Two of them are:
These components and objects are discussed in the coming sections 16.4.1 and 16.4.2. |
| Table of Contents | Previous Next |
