Java Servlets are the Java solution for providing web-based services. They provide a very similar interface for interacting with client queries and providing server responses. As such, discussion of much of the input and output in terms of HTML will overlap. Students who plan to interface with Oracle using JDBC will be working with Java Servlets.
The often-mystified abbreviation CGI, for Common Gateway Interface, refers just to a convention on how the invocation and parameter passing takes place in detail.
Invocation means different things in different cases. For a Perl script, the server would invoke a Perl interpreter and make it execute the script in an interpretive manner. For an executable program, which has typically been produced by a compiler and a loader from a source program in a language like C, it would just be started as a separate process.
In order to set up a C program as a CGI script, it needs to be turned into a binary executable program. This is often problematic, since people largely work on Windows whereas servers often run some version of UNIX or Linux. The system where you develop your program and the server where it should be installed as a CGI script may have quite different architectures, so that the same executable does not run on both of them.
This may create an unsolvable problem. If you are not allowed to log on the server and you cannot use a binary-compatible system (or a cross-compiler) either, you are out of luck. Many servers, however, allow you log on and use the server in interactive mode, as a “shell user,” and contain a C compiler.
You need to compile and load your C program on the server (or, in principle, on a system with the same architecture, so that binaries produced for it are executable on the server too).
Normally, you would proceed as follows:
Compile and test the C program in normal interactive use.
Make any changes that might be needed for use as a CGI script. The program should read its input according to the intended form submission method. Using the default GET method, the input is to be read from the environment variable. QUERY_STRING. (The program may also read data from files—but these must then reside on the server.) It should generate output on the standard output stream (stdout) so that it starts with suitable HTTP headers. Often, the output is in HTML format.
Compile and test again. In this testing phase, you might set the environment variable QUERY_STRING so that it contains the test data as it will be sent as form data. E.g., if you intend to use a form where a field named foo contains the input data, you can give the command
setenv QUERY_STRING "foo=42" (when using the tcsh shell)
or
QUERY_STRING="foo=42" (when using the bash shell).
Check that the compiled version is in a format that works on the server. This may require a recompilation. You may need to log on into the server computer (using Telnet, SSH, or some other terminal emulator) so that you can use a compiler there.
Upload the compiled and loaded program, i.e. the executable binary program (and any data files needed) on the server.
Set up a simple HTML document that contains a form for testing the script, etc.
You need to put the executable into a suitable directory and name it according to server-specific conventions. Even the compilation commands needed here might differ from what you are used to on your workstation. For example, if the server runs some flavor of Unix and has the Gnu C compiler available, you would typically use a compilation command like gcc -o mult.cgi mult.c and then move (mv) mult.cgi to a directory with a name like cgi-bin. Instead of gcc, you might need to use cc. You really need to check local instructions for such issues.
The filename extension .cgi has no fixed meaning in general. However, there can be server-dependent (and operating system dependent) rules for naming executable files. Typical extensions for executables are .cgi and .exe.
Perl Programming and CGI Scripting Course Overview:
Introduction to Perl
Origin and Design Goals of Perl
Overview of Perl Features
Getting and Installing Perl
Accessing Documentation via perldoc
HTML-Format Reference Documentation
Perl Strengths and Limitations Getting Started With Perl
Explicit Invocation of the Perl Interpreter
Running Perl on UNIX vs. Windows
Running Perl from the Command Line
Using Command Line Options
Using Debug Mode
Implicit Invocation of the Perl Interpreter
Running and Debugging Perl Scripts
Simple and Compound Statements
Fundamental Input Techniques
Using the print Function to Generate Standard Output
Using Variables
Scalar Variables
Introduction to Standard Data Types
Retrieving Standard Input Using the Default Variable $_
Reserved Scalar Variables
Assigning Strings and Numbers to Scalar Variables
Declaring Constants for Persistent Values
Using strict to Declare Variables Pattern Matching in Perl
Regular Expressions in Perl
Using Pattern Matching Operators
Altering Data with Substitutions in Regular Expressions
Using Backreferences to Capture Data from Regular Expression Matching
Global and Case-Insensitive Matches
Altering Data with Character Translation
Using Variables in Patterns
Operators
Introduction to Fundamental Operators
Operator Precedence and Associativity
Using the Ternary Operator ?: as a Shortcut for the if Statement
Using
Using the Shortcut Operators +=, -=, *=, /= String Manipulation
String Comparison
String Relations
Concatenation
Substring Manipulation
Using chomp and chop to Eliminate EOL Characters
Escape Characters for Formatting
String Manipulation Functions
Flow Control: Conditional Statements and Looping
Conditional Expressions and Logical Operators
if/else/elsif and unless
Constructing switch/case Equivalent Expressions
while Loops and do Loops
for and foreach Loops
Labels
Altering Program Flow with next, last, and redo
Trapping Errors with the eval Function
Terminating a Script with exit Subroutines and Parameters
Simplifying Scripts with Subroutines
Defining and Calling a Subroutine
Passing Arguments by Value
Passing Arguments by Reference
Using return to Return a Value
Controlling Variable Scope using my and local Keywords
Arrays and Hashes
Defining Numeric Index Arrays
Defining Associative Arrays
Sorting Arrays with the sort Function
Adding and Deleting Items Using push, pop, shift, and unshift
Using slice, splice, and reverse
Other Array Manipulation Techniques
Looping through an Array
Merging Arrays
Associative Array Manipulation Functions
Introduction to Hashes
Preallocating Memory to Optimize Hash Performance Packages and Modules
The Power of Packages and Modules
Introduction to Standard Modules
Where to Find Modules on the Internet
Installing a Module on UNIX or Windows
Creating Packages for Portability
Using Packages to Create Isolated Namespaces and to Separate Code
Creating Modules
Creating and Using Symbols in a Module
Using the Exporter to Export Symbols from a Perl Module
File and Directory I/O
Using open and close
File Open Modes
Reading Files into Arrays
Retrieving File Metadata
Built-in File Management Functions
Using print and write
File Test Operators
Directory Manipulation Using opendir, closedir, readdir, chdir, mkdir and rmdir Input/Output Processing
Parsing Input
Using Standard Input, Standard Output, and Standard Error
String and Field Processing
Using Streams and Pipes
Using die to Quit with an Error
Redirecting Standard Output and Standard Error to a File
Getting Standard Input from a File
Implementing Command Line Arguments
Reading Command Line Arguments from @ARGV
Read Files Explicitly with
Manipulating Positional Parameters with push, pop, shift
Process Lists of Files
Processing Command Line Options with getopt or getopts
Analyzing Command Line Argument Values with the Getopt::Std and Getopt::Long Modules
Reserved Variables
Manipulating Identifiable Options Using GetOptions Perl Report Formatting
Defining Report Formats
Justifying Text (Left, Right, Center)
Using write to Generate Reports
Defining here Documents for Report Customization
Creating Report Headers
Using Built-in Variables to Control Report Appearance
Printing Line Numbers on a Report
Formatting Multi-Line Output
Writing Formatted Text to a File
Debugging In Perl
Using the Built-in Perl Debugger
Starting the Debugger
Debugger Command Syntax
Checking for Script Syntax Errors
Solving Compile-Time Errors
Single-Stepping through a Script
Executing to Breakpoints
Setting Global Watches
Printing Values of Variables
Listing All Variables Used in the Script
Using Strict Error Checking
Quitting the Debugger References
Life Cycle of a Reference
Hard References and Anonymous References
Use of References to Create Complex Data Structures
Creating Hard and Anonymous References
Modifying References
Dereferencing a Reference
The Arrow Operator ->
Building Complex Data Structures with Multi-Dimensional Arrays and Hashes
Accessing a Database Using Perl DBI
Database Access Life Cycle
Using DBI and DBD to Connect to a Database
Fundamental Data Storage and Retrieval Strategies
DBI Query Syntax
Using DBI Methods to Retrieve Database Information
Preparing Queries to be Executed
Creating Parameterized Queries
Executing Queries Using execute and do
Fetching the Result Set to Achieve Workable Data in the Perl Script
Extracting Data Using an Array
Extracting Data Using a Hash
Useful Utilities to Aid in Database Development
Using Other Modules to Access Databases on the Web
Extracting Data Using a Hash
Displaying Results from Queries in a Report
Releasing Database Resources Perl Object Oriented Programming
Object Oriented Programming Concepts
Object Oriented Programming Terminology
How Perl Implements Object Oriented Programming
Modeling Software Objects Using Classes and Base Classes
Creating Classes, Objects, Methods and Attributes
Writing Constructors to Initialize of Objects
Using bless to Turn References into Objects
Creating Class Hierarchies through Inheritance
Web Architecture and CGI Scripting Overview
Static vs. Dynamic Web Pages
Serving a Static HTML Web Page
Serving a Dynamic HTML Web Page
Dynamic Web Page Capabilities
The Common Gateway Interface
How Server-Side CGI Scripts Work
Differences between Client-Side and Server-Side Script Environment
Strengths and Weaknesses of Web Programming Languages CGI Scripting with Perl
Perl's Role in Distributed Web Applications
Using Environment Variables to Control CGI Scripts
Communicating with the Web Server
Perl CGI Script Instantiation and Invocation
Generating Output for the Browser
CGI Security Mechanisms
Configuring a Web Server for CGI
Servers and CGI
The Apache httpd.conf File
Aliasing Standard Directories in Apache
Using Standard Apache-Aliased Directories
The Default Apache cgi-bin Directory
Aliasing CGI-Enabled Directories in Apache Fundamentals of CGI Scripting with Perl
Perl's Role in Distributed Web Applications
Using Environment Variables to Control CGI Scripts
Communicating with the Web Server
Perl CGI Script Instantiation and Invocation
Generating Output for the Browser
CGI Security Mechanisms
The Importance of the "Shebang" Line
"Shebang" Line CGI Errors
Debugging CGI Errors
Linux vs. Windows File Format Errors
Setting Linux File Protections
Specifying the Page MIME Type
Generating Standards-Compliant HTML
Generating Dynamic Web Pages Using Perl/CGI
Generating Dynamic Web Pages and Dynamic Content
The Role of JavaScript
Generating JavaScript Using CGI
Displaying Data in Tables
Using Environment Variables to Control CGI Scripts
Displaying Data from Files
CGI Output Stream Buffering Dynamic Behavior Based on Query Strings
The Query String Part of a URL
Parsing the Query String
Using Query Strings to Maintain Session State
User-Defined Modules and CGI
Processing HTML Forms with Perl CGI
Creating and Submitting HTML Forms
HTML Input Elements
Submitting a Form
Form Interaction Summary
Populating Form Elements Using CGI
Processing HTML Forms
Characteristics of the GET Method
GET Method Environment Variables
Characteristics of the POST Method
POST Method Environment Variables
Using Form Data Validation to Check Data Values Using the Perl CGI.pm Module - Introduction
Orientation to CGI.pm
The Power of Perl-Supplied Routines
Simplifying Debugging
Using CGI.pm in Object-Oriented Style
Named Parameter Syntax
Using CGI.pm in Procedural Style
Importing Groups of CGI.pm Methods
CGI.pm Output and XHTML
Mixing CGI.pm Methods with Standard Perl
Custom Tag Generation
Form Processing with CGI.pm
Classes of CGI.pm Methods
Specifying Arguments for HTML Tags
Differentiating Blank & Missing Parameters
Using Passed Parameters as Numbers Maintaining State with CGI.pm
State Information and the Web
Using Extra Path Information
Using Hidden Fields in Forms
Using Client-Side Cookies
Setting Cookies
Cookie Parameters
Setting Cookies from Form Data
Deleting Cookies
Form Validation and Cookie Storage
Cookie Deletion
Overcoming Cookie Limitations
Performance Optimization Using ModPerl
Overview of Apache Web Server Functionality
Comparing the Speed of CGI Scripting vs. ModPerl
Configuring Apache with Perl and ModPerl
Apache Strengths and Limitations
Using the Apache::Registry Module
Extending and Enhancing Apache Functionality Developing Multi-Tiered Web Applications
Review of Multi-Tiered Web Application Components
Putting It All Together
Using High-Level Packages to Assist with Scalability and Maintainability
No comments:
Post a Comment