REALbasic CGIs
Volume Number: 16
Issue Number: 4
Column Tag: Programming
REALbasic CGI’s
by Diana Cassady
Contributiong Editor, Erick Tejkowski
About REALbasic
REALbasic is an object-oriented implementation of the BASIC programming language
for Mac OS, and is available from REAL Software at .
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.
CGI Basics
A CGI for Mac OS needs to accomplish three main tasks:
1. Accept the Apple event from the web server.
2. Process the data contained in the Apple event.
3. 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
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
post_args=event.Stringparam("post")
end if
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.
crlf=chr(13)+chr(10)
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+"Thanks for submitting
your info.
event.ReplyString=return_string
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
the_user=event.Stringparam("user")
the_agnt=event.Stringparam("Agnt")
event.ReplyString="Hi " + the_user + ". I see you're using " +
the_agnt + ".
end if
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.
Data Processing
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:
first+name=Joe&last+name=Cool&address=123+Summer+Brook+
Lane&phone=555-1212
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.
num_fields=CountFields(post_args, "&")
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)
Next
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.
loc_hex=inStr(a_deplus, "%")
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.
char1=left(a_hex, 1)
char2=right(a_hex, 1)
Use a case statement to map the appropriate numbers to the characters.
Select Case char1
Case "0
num1=0
Case "1
num1=1
End Select
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
Case "0
num2=0
Case "1
num2=1
End Select
Multiply num2 by sixteen and add that to num1 to get the ascii equivalent of the
encoded character.
ascii_equiv=(num1*16)+num2
Convert the ascii equivalent back to the original character using the REALbasic chr()
function.
de_hex=chr(ascii_equiv)
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.
num1=Dehex(char1)
num2=Dehex(char2)
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.
Code Shortcut
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 .
Conclusion
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 diana@vivaladata.com.