doc/fcgi-devel-kit.htm

   1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <HTML>
   3    <HEAD>
   4       <TITLE>
   5          FastCGI Developer&#39;s Kit
   6       </TITLE>
   7 <STYLE TYPE="text/css">
   8  body {
   9   background-color: #FFFFFF;
  10   color: #000000;
  11  }
  12  :link { color: #cc0000 }
  13  :visited { color: #555555 }
  14  :active { color: #000011 }
  15  h5.c3 {text-align: center}
  16  h3.c2 {text-align: center}
  17  p.c1 {text-align: center}
  18 </STYLE>
  19    </HEAD>
  20    <BODY>
  21       <P CLASS="c1">
  22          <IMG BORDER="0" SRC="../images/fcgi-hd.gif" ALT="[[FastCGI]]"><BR CLEAR="all">
  23       </P>
  24       <H3 CLASS="c2">
  25          FastCGI Developer&#39;s Kit
  26       </H3>
  27       <!--Copyright (c) 1996 Open Market, Inc.                                    -->
  28       <!--See the file "LICENSE.TERMS" for information on usage and redistribution-->
  29       <!--of this file, and for a DISCLAIMER OF ALL WARRANTIES.                   -->
  30       <P CLASS="c1">
  31          Mark R. Brown<BR>
  32           Open Market, Inc.<BR>
  33       </P>
  34       <P CLASS="c1">
  35          Document Version: 1.08<BR>
  36           11 June 1996<BR>
  37       </P>
  38       <H5 CLASS="c3">
  39          Copyright &copy; 1996 Open Market, Inc. 245 First Street, Cambridge, MA 02142 U.S.A.<BR>
  40           Tel: 617-621-9500 Fax: 617-621-1703 URL: <A HREF=
  41          "http://www.openmarket.com/">http://www.openmarket.com/</A><BR>
  42           $Id: fcgi-devel-kit.htm,v 1.6 2002/02/25 00:42:59 robs Exp $<BR>
  43       </H5>
  44       <HR>
  45       <UL TYPE="square">
  46          <LI>
  47             <A HREF="#S1">1. Introduction</A>
  48          </LI>
  49          <LI>
  50             <A HREF="#S2">2. Getting started</A>
  51          </LI>
  52          <LI>
  53             <A HREF="#S3">3. Writing applications</A>
  54             <UL TYPE="square">
  55                <LI>
  56                   <A HREF="#S3.1">3.1 Using the <TT>fcgi_stdio</TT> library</A>
  57                </LI>
  58                <LI>
  59                   <A HREF="#S3.2">3.2 Using the <TT>fcgiapp</TT> library</A>
  60                </LI>
  61                <LI>
  62                   <A HREF="#S3.3">3.3 Using Perl and Tcl</A>
  63                </LI>
  64                <LI>
  65                   <A HREF="#S3.4">3.4 Using Java</A>
  66                </LI>
  67             </UL>
  68          </LI>
  69          <LI>
  70             <A HREF="#S4">4. Running applications</A>
  71             <UL TYPE="square">
  72                <LI>
  73                   <A HREF="#S4.1">4.1 Using a Web server that supports FastCGI</A>
  74                </LI>
  75                <LI>
  76                   <A HREF="#S4.2">4.2 Using <TT>cgi-fcgi</TT> with any Web server</A>
  77                </LI>
  78             </UL>
  79          </LI>
  80          <LI>
  81             <A HREF="#S5">5. Known problems</A>
  82          </LI>
  83          <LI>
  84             <A HREF="#S6">6. Getting support</A>
  85          </LI>
  86       </UL>
  87       <HR>
  88       <H3>
  89          <A NAME="S1">1. Introduction</A>
  90       </H3>
  91       <P>
  92          FastCGI is an open extension to CGI that provides high performance for all Internet applications without the
  93          penalties of Web server APIs.
  94       </P>
  95       <P>
  96          FastCGI is designed to be layered on top of existing Web server APIs. For instance, the <TT>mod_fastcgi</TT>
  97          Apache module adds FastCGI support to the Apache server. FastCGI can also be used, with reduced functionality
  98          and reduced performance, on any Web server that supports CGI.
  99       </P>
 100       <P>
 101          This FastCGI Developer&#39;s Kit is designed to make developing FastCGI applications easy. The kit currently
 102          supports FastCGI applications written in C/C++, Perl, Tcl, and Java.
 103       </P>
 104       <P>
 105          This document:
 106       </P>
 107       <UL TYPE="square">
 108          <LI>
 109             Describes how to configure and build the kit for your development platform.
 110          </LI>
 111          <LI>
 112             Tells how to write applications using the libraries in the kit.
 113          </LI>
 114          <LI>
 115             Tells how to run applications using Web servers that support FastCGI or using any Web server and
 116             <TT>cgi-fcgi</TT>.
 117          </LI>
 118       </UL>
 119       <P>
 120          The kit includes a <A HREF="fastcgi-whitepaper/fastcgi.htm">technical white paper</A>,
 121          <TT>doc/fastcgi-whitepaper/fastcgi.htm</TT>. You should read at least the first three sections of the
 122          technical white paper before starting to write FastCGI applications. The <A HREF="fcgi-perf.htm">performance
 123          paper</A> will help you understand how application design affects performance with FastCGI.
 124       </P>
 125       <P>
 126          The <A HREF="fcgi-spec.html">FastCGI Specification</A>, <TT>doc/fcgi-spec.html</TT>, defines the interface
 127          between a FastCGI application and a Web server that supports FastCGI. The software in the kit implements the
 128          specification. You don&#39;t need to read the specification in order to write applications.
 129       </P>
 130       <P>
 131          Additional information is provided in the <A HREF="http://fastcgi.com/docs/faq.html">FAQ</A> document, which
 132          contains frequently asked questions about application development using FastCGI, as well as some general
 133          information.
 134       </P>
 135       <P>
 136          Experience with CGI programming will be extremely valuable in writing FastCGI applications. If you don&#39;t
 137          have enough experience with CGI programming, you should read one of the popular books on the topic or study
 138          the <A HREF="http://hoohoo.ncsa.uiuc.edu/cgi/">NCSA CGI page</A>. For a more formal treatment of CGI/1.1 see
 139          the <A HREF="http://cgi-spec.golux.com/">Internet Draft CGI 1.1 Specification</A>.
 140       </P>
 141       <H3>
 142          <A NAME="S2">2. Getting started</A>
 143       </H3>
 144       <P>
 145          The kit is a compressed tar (tar.Z) file, distributed via the <A HREF="http://fastcgi.com/">fastcgi.com</A>
 146          Web page. Unpacking the tar file creates a new directory <TT>fcgi-devel-kit</TT>.
 147       </P>
 148       <P>
 149          Open the kit&#39;s index page, <TT>fcgi-devel-kit/index.html</TT>, using the &quot;Open File&quot; command in
 150          your Web browser. The index page gives you an overview of the kit structure and helps you navigate the kit.
 151          The index page also contains links that run some example applications, but the applications won&#39;t work
 152          when index.html is opened using the &quot;Open File&quot; command because they aren&#39;t aren&#39;t being
 153          accessed through a Web server.
 154       </P>
 155       <P>
 156          In order to use the kit in earnest you&#39;ll need a Web server that you control, a Web server running with
 157          your user ID. The Web server will be starting FastCGI applications that you will need to debug; this will be a
 158          lot more convenient for you if these processes run with your user ID. It is best to have a Web server that
 159          supports FastCGI. <A HREF="#S4">Section 4</A> discusses Web server issues.
 160       </P>
 161       <P>
 162          If you can, keep the kit on a file system accessible from your personal workstation, do your builds on your
 163          workstation, and run your Web server on your workstation. If that&#39;s not possible, arrange a configuration
 164          such that the kit is accessible from the machine that&#39;s going to run your Web server, and build the kit
 165          and your applications on a machine that&#39;s configured exactly the same way (same processor architecture,
 166          operating system, etc.) as the machine that&#39;s going to run your Web server.
 167       </P>
 168       <P>
 169          To build the kit you execute this sequence of commands in the <TT>fcgi-devel-kit</TT> directory:
 170       </P>
 171 <PRE>
 172     % ./configure
 173     % make
 174 </PRE>
 175       <P>
 176          We&#39;ve built and exercised the kit on these platforms (listed in alphabetical order):
 177       </P>
 178       <UL TYPE="square">
 179          <LI>
 180             BSD/OS 1.1 (Intel Pentium), gcc
 181          </LI>
 182          <LI>
 183             Digital UNIX V3.2 148 (Alpha), gcc/cc
 184          </LI>
 185          <LI>
 186             Hewlett-Packard HP-UX A.09.05 C and B.10.01 A (PA-RISC), gcc/cc
 187          </LI>
 188          <LI>
 189             IBM AIX 1 4 (RS/6000), gcc
 190          </LI>
 191          <LI>
 192             Silicon Graphics IRIX 5.3 11091812 (MIPS), gcc
 193          </LI>
 194          <LI>
 195             Sun Solaris 2.4 and 2.5 (SPARC), gcc/cc
 196          </LI>
 197          <LI>
 198             Sun SunOS 4.1.4 (SPARC), gcc
 199          </LI>
 200       </UL>
 201       <P>
 202          Once you&#39;ve built the kit, follow the directions in <A HREF="#S4">Section 4</A> to bring up your Web
 203          server and run the example applications.
 204       </P>
 205       <H3>
 206          <A NAME="S3">3. Writing applications</A>
 207       </H3>
 208       <H4>
 209          <A NAME="S3.1">3.1 Using the <TT>fcgi_stdio</TT> library</A>
 210       </H4>
 211       <P>
 212          The <TT>fcgi_stdio</TT> library provides the easiest transition for C CGI programs and C CGI programmers to
 213          FastCGI. Using this library your application can run using either CGI or FastCGI, with the same binary for
 214          both situations.
 215       </P>
 216       <P>
 217          To introduce the <TT>fcgi_stdio</TT> library we give a pair of examples: a tiny CGI program and the
 218          translation of this program to FastCGI. These two example programs are included in the kit.
 219       </P>
 220       <P>
 221          The CGI program is <TT>examples/tiny-cgi.c</TT>:
 222       </P>
 223 <PRE>
 224     #include &lt;stdio.h&gt;
 225     #include &lt;stdlib.h&gt;
 226
 227     void main(void)
 228     {
 229         int count = 0;
 230         printf(&quot;Content-type: text/html\r\n&quot;
 231                &quot;\r\n&quot;
 232                &quot;&lt;title&gt;CGI Hello!&lt;/title&gt;&quot;
 233                &quot;&lt;h1&gt;CGI Hello!&lt;/h1&gt;&quot;
 234                &quot;Request number %d running on host &lt;i&gt;%s&lt;/i&gt;\n&quot;,
 235                ++count, getenv(&quot;SERVER_NAME&quot;));
 236     }
 237 </PRE>
 238       <P>
 239          The key features of this tiny CGI program are:
 240       </P>
 241       <UL TYPE="square">
 242          <LI>
 243             The program sends data to the Web server by writing to <TT>stdout</TT>, using <TT>printf</TT> in this
 244             example. The CGI program first sends a <TT>Content-type</TT> header, then a small HTML document. The
 245             program includes <TT>stdio.h</TT> in order to get access to the <TT>printf</TT> function.
 246          </LI>
 247          <LI>
 248             The program obtains parameters provided by the Web server by reading environment variables. The CGI program
 249             reads the <TT>SERVER_NAME</TT> variable using <TT>getenv</TT> and includes the value in the HTML document.
 250             The program includes <TT>stdlib.h</TT> in order to get access to the <TT>getenv</TT> function.
 251          </LI>
 252       </UL>
 253       <P>
 254          The <TT>count</TT> variable is degenerate in this example; the CGI program runs a single request, so the
 255          request number is always one. This variable will be more interesting in the FastCGI example.
 256       </P>
 257       <P>
 258          <A NAME="S3.1.1">The</A> corresponding FastCGI program is <TT>examples/tiny-fcgi.c</TT>:
 259       </P>
 260 <PRE>
 261     #include &quot;fcgi_stdio.h&quot;
 262     #include &lt;stdlib.h&gt;
 263
 264     void main(void)
 265     {
 266         int count = 0;
 267         while(FCGI_Accept() &gt;= 0)
 268             printf(&quot;Content-type: text/html\r\n&quot;
 269                    &quot;\r\n&quot;
 270                    &quot;&lt;title&gt;FastCGI Hello!&lt;/title&gt;&quot;
 271                    &quot;&lt;h1&gt;FastCGI Hello!&lt;/h1&gt;&quot;
 272                    &quot;Request number %d running on host &lt;i&gt;%s&lt;/i&gt;\n&quot;,
 273                     ++count, getenv(&quot;SERVER_NAME&quot;));
 274     }
 275 </PRE>
 276       <P>
 277          The key features of this tiny FastCGI program are:
 278       </P>
 279       <UL TYPE="square">
 280          <LI>
 281             The program is structured as a loop that begins by calling the function <TT>FCGI_Accept</TT>. The
 282             <TT>FCGI_Accept</TT> function blocks until a new request arrives for the program to execute. The program
 283             includes <TT>fcgi_stdio.h</TT> in order to get access to the <TT>FCGI_Accept</TT> function.
 284          </LI>
 285          <LI>
 286             Within the loop, <TT>FCGI_Accept</TT> creates a CGI-compatible world. <TT>printf</TT> and <TT>getenv</TT>
 287             operate just as in the CGI program. <TT>stdin</TT> and <TT>stderr</TT>, not used by this tiny program, also
 288             operate just as in a CGI program.
 289          </LI>
 290       </UL>
 291       <P>
 292          The <TT>count</TT> variable increments each time through the loop, so the program displays a new request
 293          number each time. You can use the reload button in your browser to demonstrate this, once you&#39;ve got the
 294          program built and running.
 295       </P>
 296       <H4>
 297          Building the program
 298       </H4>
 299       <P>
 300          If you can build <TT>examples/tiny-cgi.c</TT>, it will be straightforward for you to build
 301          <TT>examples/tiny-fcgi.c</TT>. You need to:
 302       </P>
 303       <UL TYPE="square">
 304          <LI>
 305             Add the directory containing the <TT>fcgi_stdio.h</TT> header to the compiler&#39;s include search path.
 306             The kit calls this directory <TT>include</TT>.
 307          </LI>
 308          <LI>
 309             Add the library <TT>libfcgi.a</TT> to the linker&#39;s command line so that it will be searched when
 310             linking. The <TT>libfcgi.a</TT> library implements the functions defined in <TT>fcgi_stdio.h</TT>. The kit
 311             calls the directory containing this library <TT>libfcgi</TT>.
 312          </LI>
 313          <LI>
 314             Determine whether or not the linker on your platform searches the Berkeley socket library by default, and
 315             if not, add linker directives to force this search.
 316          </LI>
 317       </UL>
 318       <P>
 319          See <TT>examples/Makefile</TT> (created by <TT>configure</TT>) for a Makefile that builds both programs.
 320          Autoconf handles the platform-dependent linking issues; to see how, examine <TT>configure.in</TT> and
 321          <TT>examples/Makefile.in</TT>.
 322       </P>
 323       <H4>
 324          Running the program
 325       </H4>
 326       <P>
 327          <A HREF="#S4">Section 4</A> is all about how to run FastCGI applications.
 328       </P>
 329       <P>
 330          You can use CGI to run application binaries built with the <TT>fcgi_stdio</TT> library. The
 331          <TT>FCGI_Accept</TT> function tests its environment to determine how the application was invoked. If it was
 332          invoked as a CGI program, the first call to FCGI_Accept is essentially a no-op and the second call returns
 333          <TT>-1</TT>. In effect, the request loop disappears.
 334       </P>
 335       <P>
 336          Of course, when a FastCGI application is run using CGI it does not get the benefits of FastCGI. For instance,
 337          the application exits after servicing a single request, so it cannot maintain cached information.
 338       </P>
 339       <H4>
 340          Implementation details
 341       </H4>
 342       <P>
 343          <TT>fcgi_stdio.h</TT> works by first including <TT>stdio.h</TT>, then defining macros to replace essentially
 344          all of the types and procedures defined in <TT>stdio.h</TT>. (<TT>stdio.h</TT> defines a few procedures that
 345          have nothing to do with <TT>FILE *</TT>, such as <TT>sprintf</TT> and <TT>sscanf</TT>; <TT>fcgi_stdio.h</TT>
 346          doesn&#39;t replace these.) For instance, <TT>FILE</TT> becomes <TT>FCGI_FILE</TT> and <TT>printf</TT> becomes
 347          <TT>FCGI_printf</TT>. You&#39;ll only see these new names if you read <TT>fcgi_stdio.h</TT> or examine your C
 348          source code after preprocessing.
 349       </P>
 350       <P>
 351          Here are some consequences of this implementation technique:
 352       </P>
 353       <UL TYPE="square">
 354          <LI>
 355             On some platforms the implementation will break if you include <TT>stdio.h</TT> after including
 356             <TT>fcgi_stdio.h</TT>, because <TT>stdio.h</TT> often defines macros for functions such as <TT>getc</TT>
 357             and <TT>putc</TT>. Fortunately, on most platforms <TT>stdio.h</TT> is protected against multiple includes
 358             by lines near the top of the file that look like
 359 <PRE>
 360     #ifndef _STDIO_H
 361     #define _STDIO_H
 362
 363 </PRE>
 364             <P>
 365                The specific symbol used for multiple-include protection, <TT>_STDIO_H</TT> in this example, varies from
 366                platform to platform. As long as your platform protects <TT>stdio.h</TT> against multiple includes, you
 367                can forget about this issue.
 368             </P>
 369          </LI>
 370          <LI>
 371             If your application passes <TT>FILE *</TT> to functions implemented in libraries for which you have source
 372             code, then you&#39;ll want to recompile these libraries with <TT>fcgi_stdio.h</TT> included. Most C
 373             compilers provide a command-line option for including headers in a program being compiled; using such a
 374             compiler feature allows you to rebuild your libraries without making source changes. For instance the gcc
 375             command line
 376 <PRE>
 377     gcc -include /usr/local/include/fcgi_stdio.h wonderlib.c
 378
 379 </PRE>
 380             <P>
 381                causes gcc to include <TT>fcgi_stdio.h</TT> before it even begins to read the module
 382                <TT>wonderlib.c</TT>.
 383             </P>
 384          </LI>
 385          <LI>
 386             If your application passes <TT>FILE *</TT> to functions implemented in libraries for which you do not have
 387             source code, then you&#39;ll need to include the headers for these libraries <I>before</I> you include
 388             <TT>fcgi_stdio.h</TT>. You can&#39;t pass the <TT>stdin</TT>, <TT>stdout</TT>, or <TT>stderr</TT> streams
 389             produced by <TT>FCGI_Accept</TT> to any functions implemented by these libraries. You can pass a stream on
 390             a Unix file to a library function by following this pattern:
 391 <PRE>
 392     FILE *myStream = fopen(path, &quot;r&quot;);
 393     answer = MungeStream(FCGI_ToFile(myStream));
 394
 395 </PRE>
 396             <P>
 397                Here <TT>MungeStream</TT> is a library function that you can&#39;t recompile and <TT>FCGI_ToFile</TT> is
 398                a macro that converts from <TT>FCGI_FILE *</TT> to <TT>FILE *</TT>. The macro <TT>FCGI_ToFile</TT> is
 399                defined in <TT>fcgi_stdio.h</TT>.
 400             </P>
 401          </LI>
 402       </UL>
 403       <H4>
 404          Converting CGI programs
 405       </H4>
 406       <P>
 407          The main task in converting a CGI program into a FastCGI program is separating the code that needs to execute
 408          once, initializing the program, from the code that needs to run for each request. In our tiny example,
 409          initializing the <TT>count</TT> variable is outside the loop, while incrementing the <TT>count</TT> variable
 410          goes inside.
 411       </P>
 412       <P>
 413          Retained application state may be an issue. You must ensure that any application state created in processing
 414          one request has no unintended effects on later requests. FastCGI offers the possibility of significant
 415          application performance improvements, through caching; it is up to you to make the caches work correctly.
 416       </P>
 417       <P>
 418          Storage leaks may be an issue. Many CGI programs don&#39;t worry about storage leaks because the programs
 419          don&#39;t run for long enough for bloating to be a problem. When converting to FastCGI, you can either use a
 420          tool such as <A HREF="http://www.pure.com/"><I>Purify</I></A> from Pure Software to discover and fix storage
 421          leaks, or you can run a C garbage collector such as <A HREF="http://www.geodesic.com/"><I>Great Circle</I></A>
 422          from Geodesic Systems.
 423       </P>
 424       <H4>
 425          Limitations
 426       </H4>
 427       <P>
 428          Currently there are some limits to the compatibility provided by the <TT>fcgi_stdio</TT> library:
 429       </P>
 430       <UL TYPE="square">
 431          <LI>
 432             The library does not provide FastCGI versions of the functions <TT>fscanf</TT> and <TT>scanf</TT>. If you
 433             wish to apply <TT>fscanf</TT> or <TT>scanf</TT> to <TT>stdin</TT> of a FastCGI program, the workaround is
 434             to read lines or other natural units into memory and then call <TT>sscanf</TT>. If you wish to apply
 435             <TT>fscanf</TT> to a stream on a Unix file, the workaround is to follow the pattern:
 436 <PRE>
 437     FILE *myStream = fopen(path, &quot;r&quot;);
 438     count = fscanf(FCGI_ToFile(myStream), format, ...);
 439
 440 </PRE>
 441          </LI>
 442       </UL>
 443       <H4>
 444          Reference documentation
 445       </H4>
 446       <P>
 447          The <A HREF="FCGI_Accept.3"><TT>FCGI_Accept</TT> manpage</A>, <TT>doc/FCGI_Accept.3</TT>, describes the
 448          function in the traditional format.
 449       </P>
 450       <P>
 451          The <A HREF="FCGI_Finish.3"><TT>FCGI_Finish</TT></A> (<TT>doc/FCGI_Finish.3</TT>), <A HREF=
 452          "FCGI_SetExitStatus.3"><TT>FCGI_SetExitStatus</TT></A> (<TT>doc/FCGI_SetExitStatus.3</TT>), and <A HREF=
 453          "FCGI_StartFilterData.3"><TT>FCGI_StartFilterData</TT></A> (<TT>doc/FCGI_StartFilterData.3</TT>) manpages
 454          document capabilities of the <TT>fcgi-stdio</TT> library that are not illustrated above.
 455       </P>
 456       <H4>
 457          <A NAME="S3.2">3.2 Using the <TT>fcgiapp</TT> library</A>
 458       </H4>
 459       <P>
 460          The <TT>fcgiapp</TT> library is a second C library for FastCGI. It does not provide the high degree of source
 461          code compatibility provided by <TT>fcgi_stdio</TT>; in return, it does not make such heavy use of
 462          <TT>#define</TT>. <TT>fcgi_stdio</TT> is implemented as a thin layer on top of <TT>fcgiapp</TT>.
 463       </P>
 464       <P>
 465          Applications built using the <TT>fcgiapp</TT> library cannot run as CGI programs; that feature is provided at
 466          the <TT>fcgi_stdio</TT> level.
 467       </P>
 468       <P>
 469          Functions defined in <TT>fcgiapp</TT> are named using the prefix <TT>FCGX_</TT> rather than <TT>FCGI_</TT>.
 470          For instance, <TT>FCGX_Accept</TT> is the <TT>fcgiapp</TT> version of <TT>FCGI_Accept</TT>.
 471       </P>
 472       <P>
 473          Documentation of the <TT>fcgiapp</TT> library takes the form of extensive comments in the header file
 474          <TT>include/fcgiapp.h</TT>. The sample programs <TT>examples/tiny-fcgi2.c</TT> and <TT>examples/echo2.c</TT>
 475          illustrate how to use <TT>fcgiapp</TT>.
 476       </P>
 477       <H4>
 478          <A NAME="S3.3">3.3 Using Perl and Tcl</A>
 479       </H4>
 480       <P>
 481          A major advantage of the FastCGI approach to high-performance Web applications is its language-neutrality. CGI
 482          scripts written in popular languages such as Perl and Tcl can be evolved into high-performance FastCGI
 483          applications.
 484       </P>
 485       <P>
 486          We have produced FastCGI-integrated Perl and Tcl interpreters. Doing so was easy, since Perl and Tcl are
 487          conventional C applications and <TT>fcgi_stdio</TT> was designed for converting conventional C applications.
 488          Essentially no source code changes were required in these programs; a small amount of code was added in order
 489          to make <TT>FCGI_Accept</TT> and other FastCGI primitives available in these languages. And because these
 490          interpreters were developed using <TT>fcgi_stdio</TT>, they run standard Perl and Tcl applications (e.g. CGI
 491          scripts) as well as FastCGI applications.
 492       </P>
 493       <P>
 494          See the <A HREF="http://fastcgi.com">fastcgi.com</A> Web page for more information about the Perl and Tcl
 495          libraries.
 496       </P>
 497       <P>
 498          Here are the Perl and Tcl versions of <TT>tiny-fcgi</TT>:
 499       </P>
 500 <PRE>
 501 #!./perl
 502 use FCGI;
 503 $count = 0;
 504 while(FCGI::accept() &gt;= 0) {
 505     print(&quot;Content-type: text/html\r\n\r\n&quot;,
 506           &quot;&lt;title&gt;FastCGI Hello! (Perl)&lt;/title&gt;\n&quot;,
 507           &quot;&lt;h1&gt;FastCGI Hello! (Perl)&lt;/h1&gt;\n&quot;;
 508           &quot;Request number &quot;,  ++$count,
 509           &quot; running on host &lt;i&gt;&quot;;$env(SERVER_NAME)&lt;/i&gt;&quot;);
 510 }
 511 </PRE>
 512 <PRE>
 513 #!./tclsh
 514 set count 0
 515 while {[FCGI_Accept] &gt;= 0 } {
 516     incr count
 517     puts -nonewline &quot;Content-type: text/html\r\n\r\n&quot;
 518     puts &quot;&lt;title&gt;FastCGI Hello! (Tcl)&lt;/title&gt;&quot;
 519     puts &quot;&lt;h1&gt;FastCGI Hello! (Tcl)&lt;/h1&gt;&quot;
 520     puts &quot;Request number $count running on host &lt;i&gt;$env(SERVER_NAME)&lt;/i&gt;&quot;
 521 }
 522 </PRE>
 523       <P>
 524          Converting a Perl or Tcl CGI application to FastCGI is not fundamentally different from converting a C CGI
 525          application to FastCGI. You separate the portion of the application that performs one-time initialization from
 526          the portion that performs per-request processing. You put the per-request processing into a loop controlled by
 527          <TT>FCGI::accept</TT> (Perl) or <TT>FCGI_Accept</TT> (Tcl).
 528       </P>
 529       <H4>
 530          <A NAME="S3.4">3.4 Using Java</A>
 531       </H4>
 532       <P>
 533          Java is not just for browser-based applets. It is already suitable for writing some Web server applications,
 534          and its range of applicability will only grow as Java compilers and other Java tools improve. Java&#39;s
 535          modules, garbage collection, and threads are especially valuable for writing long-lived application servers.
 536       </P>
 537       <P>
 538          The <TT>FCGIInterface</TT> class provides facilities for Java applications analogous to what
 539          <TT>fcgi_stdio</TT> provides for C applications. Using this library your Java application can run using either
 540          CGI or FastCGI.
 541       </P>
 542       <P>
 543          The kit includes separate companion document on <A HREF="fcgi-java.htm">using FastCGI with Java</A>. The
 544          source code for FastCGI classes is contained in directory <TT>java/src</TT> and the compiled code in
 545          <TT>java/classes</TT>.
 546       </P>
 547       <P>
 548          Here is the Java version of <TT>tiny-fcgi</TT>:
 549       </P>
 550 <PRE>
 551 import FCGIInterface;
 552
 553 class TinyFCGI {
 554     public static void main (String args[]) {
 555         int count = 0;
 556         while(new FCGIInterface().FCGIaccept()&gt;= 0) {
 557             count ++;
 558             System.out.println(&quot;Content-type: text/html\r\n\r\n&quot;);
 559             System.out.println(
 560                     &quot;&lt;title&gt;FastCGI Hello! (Java)&lt;/title&gt;&quot;);
 561             System.out.println(&quot;&lt;h1&gt;FastCGI Hello! (Java)&lt;/h1&gt;&quot;);
 562             System.out.println(
 563                     &quot;request number &quot; + count + &quot; running on host &lt;i&gt;&quot; +
 564                     System.getProperty(&quot;SERVER_NAME&quot;) + &quot;&lt;/i&gt;&quot;);
 565         }
 566     }
 567 }
 568 </PRE>
 569       <H3>
 570          <A NAME="S4">4. Running applications</A>
 571       </H3>
 572       <H3>
 573          <A NAME="S4.1">4.1 Using a Web server that supports FastCGI</A>
 574       </H3>
 575       <P>
 576          For a current listing of Web servers that support FastCGI, see the <A HREF=
 577          "http://fastcgi.com">fastcgi.com</A> Web page.
 578       </P>
 579       <P>
 580          Some of the Web servers that support FastCGI perform management of FastCGI applications. You don&#39;t need to
 581          start and stop FastCGI applications; the Web server takes care of this. If an application process should
 582          crash, the Web server restarts it.
 583       </P>
 584       <P>
 585          Web servers support FastCGI via new configuration directives. Since these directives are server-specific, get
 586          more information from the documentation that accompanies each server.
 587       </P>
 588       <H3>
 589          <A NAME="S4.2">4.2 Using <TT>cgi-fcgi</TT> with any Web server</A>
 590       </H3>
 591       <P>
 592          The program <TT>cgi-fcgi</TT> allows you to run FastCGI applications using any Web server that supports CGI.
 593       </P>
 594       <P>
 595          Here is how <TT>cgi-fcgi</TT> works. <TT>cgi-fcgi</TT> is a standard CGI program that uses Unix domain or
 596          TCP/IP sockets to communicate with a FastCGI application. <TT>cgi-fcgi</TT> takes the path name or host/port
 597          name of a listening socket as a parameter and <TT>connect</TT>s to the FastCGI application listening on that
 598          socket. <TT>cgi-fcgi</TT> then forwards the CGI environment variables and <TT>stdin</TT> data to the FastCGI
 599          application, and forwards the <TT>stdout</TT> and <TT>stderr</TT> data from the FastCGI application to the Web
 600          server. When the FastCGI application signals the end of its response, <TT>cgi-fcgi</TT> flushes its buffers
 601          and exits.
 602       </P>
 603       <P>
 604          Obviously, having <TT>cgi-fcgi</TT> is not as good as having a server with integrated FastCGI support:
 605       </P>
 606       <UL>
 607          <LI>
 608             Communication is slower than with a Web server that avoids the fork/exec overhead on every FastCGI request.
 609          </LI>
 610          <LI>
 611             <TT>cgi-fcgi</TT> does not perform application management, so you need to provide this yourself.
 612          </LI>
 613          <LI>
 614             <TT>cgi-fcgi</TT> supports only the Responder role.
 615          </LI>
 616       </UL>
 617       <P>
 618          But <TT>cgi-fcgi</TT> does allow you to develop applications that retain state in memory between connections,
 619          which often provides a major performance boost over normal CGI. And all the applications you develop using
 620          <TT>cgi-fcgi</TT> will work with Web servers that have integrated support for FastCGI.
 621       </P>
 622       <P>
 623          The file <TT>examples/tiny-fcgi.cgi</TT> demonstrates a way to use <TT>cgi-fcgi</TT> to run a typical
 624          application, in this case the <TT>examples/tiny-fcgi</TT> application:
 625       </P>
 626 <PRE>
 627     #!../cgi-fcgi/cgi-fcgi -f
 628     -connect sockets/tiny-fcgi tiny-fcgi
 629 </PRE>
 630       <P>
 631          On most Unix platforms, executing this command-interpreter file runs <TT>cgi-fcgi</TT> with arguments
 632          <TT>-f</TT> and <TT>examples/tiny-fcgi.cgi</TT>. (Beware: On some Unix platforms, including HP-UX, the first
 633          line of a command-interpreter file cannot contain more than 32 characters, including the newline; you may need
 634          to install the <TT>cgi-fcgi</TT> application in a standard place like <TT>/usr/local/bin</TT> or create a
 635          symbolic link to the <TT>cgi-fcgi</TT> application in the directory containing your application.) The
 636          <TT>cgi-fcgi</TT> program reads the command-interpreter file and connects to the FastCGI application whose
 637          listening socket is <TT>examples/sockets/tiny-fcgi</TT>.
 638       </P>
 639       <P>
 640          Continuing the example, if <TT>cgi-fcgi</TT>&#39;s connection attempt fails, it creates a new process running
 641          the program <TT>examples/tiny-fcgi</TT> and listening on socket <TT>examples/sockets/tiny-fcgi</TT>. Then
 642          <TT>cgi-fcgi</TT> retries the connection attempt, which now should succeed.
 643       </P>
 644       <P>
 645          The <TT>cgi-fcgi</TT> program has two other modes of operation. In one mode it connects to applications but
 646          does not start them; in the other it starts applications but does not connect to them. These modes are
 647          required when using TCP/IP. The <A HREF="cgi-fcgi.1"><TT>cgi-fcgi</TT> manpage</A>, <TT>doc/cgi-fcgi.1</TT>,
 648          tells the full story.
 649       </P>
 650       <P>
 651          To run the example applications using <TT>cgi-fcgi</TT>, start your Web server and give it the directory
 652          <TT>fcgi-devel-kit</TT> as the root of its URL space. If the machine running your server is called
 653          <TT>bowser</TT> and your server is running on port <TT>8888</TT>, you&#39;d then open the URL
 654          <TT>http://bowser:8888/index.html</TT> to reach the kit&#39;s index page. Now the links on the index page that
 655          run example applications via <TT>cgi-fcgi</TT> should be active.
 656       </P>
 657       <H3>
 658          <A NAME="S5">5. Known problems</A>
 659       </H3>
 660       <P>
 661          On Digital UNIX 3.0 there&#39;s a problem with Unix domain listening sockets on NFS file systems. The symptom
 662          when using cgi-fcgi is an exit status of 38 (<TT>ENOTSOCK</TT>: socket operation on non-socket), but cgi-fcgi
 663          may dump core in this case when compiled optimized. Work-around: Store your Unix domain listening sockets on a
 664          non NFS file system, upgrade to Digital UNIX 3.2, or use TCP sockets.
 665       </P>
 666       <P>
 667          On AIX there&#39;s a problem with shared listening sockets. The symptoms can include application core dumps
 668          and kernel panic. Work-around: Run a single FastCGI application server per listening socket.
 669       </P>
 670       <H3>
 671          <A NAME="S6">6. Getting support</A>
 672       </H3>
 673       <P>
 674          The mailing list <TT>fastcgi-developers</TT> is used for discussions of issues in developing FastCGI
 675          applications. Topics include announcement of FastCGI-capable Web servers or changes to such servers,
 676          announcement of new application libraries or changes to such libraries, announcement of known bugs, discussion
 677          of design trade-offs in FastCGI application programming, and discussion of development plans and experiences.
 678          To join the list, see <A HREF=
 679          "http://fastcgi.com/fastcgi-developers">http://fastcgi.com/fastcgi-developers</A>.
 680       </P>
 681       <P>
 682          A link to a mail archive can be found on the FastCGI home page, <A HREF=
 683          "http://www.fastcgi.com">http://www.fastcgi.com</A>
 684       </P>
 685       <HR>
 686       <ADDRESS>
 687          &copy; 1996, Open Market, Inc. / mbrown@openmarket.com
 688       </ADDRESS>
 689    </BODY>
 690 </HTML>
 691