Volume Number: 16 (2000)
Issue Number: 4
Column Tag: Programming
by Diana Cassady
Contributiong Editor, Erick Tejkowski
REALbasic is an object-oriented implementation of the BASIC programming language for Mac OS, and is available from REAL Software at <http://www.realsoftware.com>. It's a language that can be mastered, even by a novice, in days. Its drag and drop builder allows programmers to create stand alone applications with windows, menu bars, text areas, radio buttons, checkboxes, and all the usual user interface features found in commercial programs that have taken months to write. REALbasic programs can send and receive Apple events to communicate with other scriptable programs, including webservers. REALbasic can be used to create a customized, stand alone CGI with an interface for webmasters to store program preferences. Real time logging results can also be displayed in a REALbasic interface.
In this article, I present a framework for writing CGI's for Mac OS Web servers using the REALbasic environment. It is assumed the reader is already familiar with the basics of authoring CGI's.
A CGI for Mac OS needs to accomplish three main tasks:
- Accept the Apple event from the web server.
- Process the data contained in the Apple event.
- Return an Apple event to the web server containing the requested data.
Accepting the Apple Event
REALbasic contains a built-in event handler to accept Apple events within a class. The application contains an event called HandleAppleEvent. This handler will contain the code to interpret incoming Apple events.
Start a new REALbasic program by opening your REALbasic application. Create a new class by choosing New Class from the File menu. Access the properties of this new class by highlighting it in the project window and choosing Show Properties under the Window menu. Choose Application beside Super in the new class properties. This application class will be the location of the Apple event handler. The new class' default name is Class1.
Double-click Class1 in the project window. The first item on the left of the Class1 window is Events. Double-click on Events. A list of events will appear. The last event in the list is HandleAppleEvent. Double-click on HandleAppleEvent to open the code window.
Three variables are provided within this handler: event as AppleEvent, eventClass as String, and eventID as String. The eventClass and eventID are used to identify the Apple event. The Apple event coming from the web server will have an eventClass of WWWOmega. The Omega sign is made with command z on the keyboard. The eventID will be sdoc. The variable event contains the data. The data coming from the web server is broken up into parameters. A list of these parameters can be found at <http://www.biap.com/DataPig/mrwheat/cgiParams.html> courtesy of Biap Systems, Inc. These parameters are for the WebStar webserver, but are common to most Macintosh webservers. A four character keyword identifies each parameter within the Apple event. Form data passed using the post method in a form action is identified by the keyword post. The event variable contains all the parameters, including the post parameter. To isolate the post parameter within the event variable, use event.Stringparam("post"). This function provides the form data as one long strong.
The code in the Apple event handler should verify that the incoming Apple event is the proper type. A string variable also needs to be initialized to contain the isolated form data.
Dim post_args as string
if eventClass="WWWOmega" and eventID="sdoc" then
Sending a Reply
The program can now accept the Apple event and isolate the data it contains. If the program wanted to collect raw form data and return a simple thank you to the user, no further code is necessary except for a reply. The reply statement sends a string back to the server which is then returned to the browser. The return string should contain a header and HTML to be returned to the user. You may want to build the return_string in pieces to make your code easier to read. The carriage Return Line Feed variable stands for control return line feed.
return_string="HTTP/1.0 200 OK" + crlf + "Server: WebSTAR/2.0 ID/ACGI"
+ crlf + "MIME-Version: 1.0" + crlf + "Content-type: text/html" + crlf + crlf
return_string=return_string+"<html><body><h2>Thanks for submitting your info.
This much code will function as a CGI. It won't do anything with the form data, but it will accept and respond to the Apple event and the web server will return the response to the browser.
The CGI will be much more useful if it can work with the information sent from the web server. Some of this information can be dealt with as is. For example, you could get the username of a user who has logged into a password protected realm by using the keyword user instead of post. You could also get the name of the web browser they're using with the keyword Agnt.
Dim the_user as string
Dim the_agnt as string
if eventClass="WWWOmega" and eventID="sdoc" then
event.ReplyString="Hi " + the_user + ". I see you're using " + the_agnt + "."
If-then statements can be incorporated to send back different replies depending on the data contained in the various Apple event parameters, or other data from the system brought in by REALbasic functions such as date and time of day.
Form parameters require more processing before the contents of the form can be interpreted. Form parameters are sent as a string with field names and values delimited with equal signs and ampersands. Spaces are represented by either "+" or encoded as "%20" (the hexidecimal value for a space character) depending on the browser. A typical form containing field names first name, last name, address and phone might look like this:
Field and value pairs are divided by ampersands and the field names are separated from the value pairs by equal signs. Separating the field and value pairs and isolating the values is the first step in decoding form data.
Several variables need to be defined for this process:
Dim post_args, one_field, field_value, field_label as string
Dim num_fields, x_field as integer
Count the number of fields on the form.
Use a For Next loop to process every field.
For x_field=1 to num_fields
one_field=NthField(post_args, "&", x_field)
field_label=NthField(one_field, "=", 1)
field_value=NthField(one_field, "=", 2)
The first line in the loop isolates a field name and value pair. The second line isolates the field name of that pair. The third line isolates the value.
If the form data consisted of one word field names and one word options with no special characters then no further processing would be needed, but most likely, the data contains spaces and other encoded special characters.
Plus signs need to be replaced with spaces within each isolated field and field label:
the_field=ReplaceAll(the_field, "+", " ")
A percent sign within the field means that it still contains encoded characters. Use the REALbasic inStr() function to get the position of the first percent sign in the string. If zero is returned, the string does not contain a percent sign. There is nothing more to decode within the isolated field.
If a value greater than zero is returned, a percent sign exists. Use the REALbasic Mid() function to isolate the character pair after the percent sign.
a_hex=Mid(a_deplus, loc_hex+1, 2)
The two characters following the percent sign are the hexadecimal version of the original character. They need to be converted to their ascii equivalent before the chr() function can be used to restore them to their original identity.
To convert the characters to their ascii equivalent, convert each to a number, multiple the first number by sixteen, and add the result to the second number.
Each character will be zero through nine or A through F as a string. Zero through nine can be taken at Its face value. A through F corresponds to the values ten through fifteen. Use the left() and right() functions to isolate each character of the pair.
Use a case statement to map the appropriate numbers to the characters.
Select Case char1
Include case statements for numbers zero through nine mapping to zero through nine and letters A through F mapping to ten through fifteen. The resulting num1 will be the ascii equivalent of the first character. Repeat the process for the second character.
Select Case char2
Multiply num2 by sixteen and add that to num1 to get the ascii equivalent of the encoded character.
Convert the ascii equivalent back to the original character using the REALbasic chr() function.
Plug the decoded character back in to the field in place of the percent sign and character pair.
the_field=ReplaceAll(the_field, "%"+a_hex, de_hex)
So far, only the first instance of an encoded character in the field has been addressed. The ReplaceAll() function has eliminated all occurances of that encoding within the field, but there may still be other encoded characters that need to be sent through this process. Every encoded character will start with a percent sign. A while loop should be used to send the field through the process until inStr(a_deplus, "%") is no longer greater than zero.
Making the Code Efficient
Repetitive code may be eliminated with subroutines. Subroutines are stored as methods in REALbasic programs. The case select code that converts a character to zero through fifteen would be a good piece of code to include as a subroutine. One set of case statements could accept a character and return a numeric value.
Define a new method in the class by choosing New Method under the Edit menu. A window appears with fields for name, parameters, and return type. Name the new method with a simple one word description like Dehex. This method accepts one character to convert to a numeric value. The character being accepted is the parameter for the method. Define that parameter in the blank provided. Include the data type.
char as string
The method returns a numeric value. Integer can be chosen to describe this value as the return type by using the pop down menu to the right of the return type field.
Enter the select case statement in the method. Send char1 and char2 through the subroutine to get num1 and num2 without wasteful code repetition.
Expanding REALbasic CGI's
This method of decoding can be applied to field names and values in post args and search args. Once field names are decoded, they may be referred to in if-then statements to format and arrange their corresponding decoded field values. Decoded data may be set to variables and sent to a text file or a scriptable application for further processing and storage. Results containing decoded data may be returned to the user to assure them that their information has been received.
The complex code for decoding search and post arguments need not be written from scratch. A code shell is available for download on the site index page of the VivaLaData web site at <http://www.vivaladata.com>.
If you happen to run across a web automation task for which you have no cgi, or if you're already running an applescript application as a cgi, you should consider using REALbasic to accomplish your goal. Several users have reported that REALbasic cgi's performed faster than their existing applescript cgi's.
REALbasic cgi's can be used to interface with scriptable programs for which no commercial cgi's have been developed. REALbasic is also a quick way for shareware authors to provide a cgi for their scriptable applications. In addition to working with other applications, REALbasic provides lots of built in functions for sending and receiving mail as well as other network protocols and data processing functions.
If you want to add a new function to your Macintosh web site, but feel a $500+ commercial solution is overkill, REALbasic's flexible, rapid development environment and reasonable price tag may be just the solution for you.
Diana Cassady is a freelance consultant in Danbury, Connecticut. Her web site is http://www.vivaladata.com. She can be reach at email@example.com.