Using C for CGI Programming

You can speed up complex Web tasks while retaining the simplicity of CGI. With many useful libraries available, the jump from a scripting language to C isn't as big as you might think.

Perl, Python and PHP are the holy trinity of CGI application
programming. Stores have shelves full of books about these languages,
they're covered well in the computer press and there's plenty on the
Internet about them. A distinct lack of information exists, however, on using
C to write CGI applications. In this article, I show how to
use C for CGI programming and lay out some situations in which it
provides significant advantages.

I use C in my applications for three reasons: speed, features and
stability. Although conventional wisdom says otherwise, my own benchmarks have
found that C and PHP are equivalent in speed when the processing to be
done is simple. When there is any complexity
to the processing, C wins hands-down.

In addition, C provides an excellent feature set. The language itself comes with a
bare-bones set of features, but a staggering number of
libraries are available for nearly any job for which a computer
is used. Perl, of course, is no slouch in this area, and I don't contend that
C offers more extensibility, but both can fill nearly any bill.

Furthermore, CGI programs written in C are stable. Because the program is
compiled, it is not as susceptible to changes in the operating
environment as PHP is. Also, because the language is stable,
it does not experience the dramatic changes to which PHP users
have been subjected over the past few years.

The Application

My application is a simple event listing suitable for a
business to list upcoming events, say, the meeting schedule for a day
or the events at a church. It provides an administrative interface
intended to be password-protected and a public interface that lists
all upcoming events (but only upcoming events). This application also
provides for
runtime configuration and interface independence.

I use a database, rather than write my own data
store, and a configuration file contains the database
connection information. A collection of files is used
to provide interface/code separation.

The administrative interface allows events to be listed, edited,
saved and deleted. Listing events is the default action if no
other action is provided. Both new and existing events can be saved.
The interface consists of a grid screen that displays the list of
events and a detail screen that contains the full record of a single
event.

The database schema for this application consists of a single table,
defined in Listing 1. This schema is MySQL-specific, but an equivalent
schema can be created for any database engine.

The following functions are the minimum necessary to implement the
functionality of the administrative interface: list_events(),
show_event(), save_event() and delete_event().
I also am going to abstract the reading and writing of database data
into their own group of functions. This keeps each function simpler,
which makes debugging easier. The functions that I need for the
data-storage interface are event_create(), event_destroy(),
event_read(), event_write and event_delete. To make my life easier,
I'm also going to add event_fetch_range(), so I can choose a range
of events—something I need to do in at least two places.

Next, I need to abstract my records to C structures and abstract database
result sets to linked lists. Abstraction lets me change database
engines or data representation with relatively little expense, because
only a little part of my code deals directly with the data store.

There isn't room here to print all of my source code.
Complete source code and my Makefile can be downloaded from my Web
site (see the on-line Resources).

Tools

The first hurdle to overcome when using C is acquiring the set of tools you
need. At bare minimum, you need a CGI parser to break out the
CGI information for you. Chances are good that you're also
looking for some database connectivity. A little bit of
logic/interface independence is good too, so you aren't
rewriting code every time the site needs a makeover.

For CGI parsing, I recommend the cgic library from Thomas Boutell (see
Resources). It's shockingly easy to use and
provides access to all parts of the CGI interface. If you're a C++
person, the cgicc libraries also are suitable (see Resources),
although I found the Boutell library to be easier to use.

MySQL is pretty much the standard for UNIX Web development,
so I stick with it for my sample application. Every significant
database engine has a functional C interface library, though, so you
can use whatever database you like.

I'm going to provide my own interface-independence routines, but you
could use libxml and libxslt to do the same thing with a good deal
more sophistication.