apache内容生成器 (3)

Myth丶恋晨 2022-06-09 23:53 190阅读 0赞

13.10  创建自己的处理器

在了解了处理器的细节之后我们就可以创建自己的处理器了。本章中我们将创建一个简单的处理器example\_handler，该处理器的作用很简单，只是返回固定的报文信息。

13.10.1 定义处理器

在创建自己的过滤器之前，你必须首先要考虑清楚你的处理器的名称以及它在什么条件下会被调用。对于我们的示例处理器而言，处理器的名称为”example\_handler”，它的触发条件则如下所示：

SetHandler example\_handler

</Location>

example\_handler在URI为*http://xxx.xxx.xxx/example\_status*的时候被触发，为此我们必须在配置文件httpd.conf中增加上面的配置信息。

13.10.2 声明处理器

一旦确定处理的名称，那么我们就可以定义该处理器。事实上处理器是一种名为handler的特殊的挂钩，因此声明处理器就是声明handler挂钩的一个实例：

ap\_hook\_handler(example\_handler, NULL, NULL, APR\_HOOK\_MIDDLE);

该声明将在指定模块的register\_hooks中被注册。

13.10.3  实现处理器

在注册处理器的时候我们可以看到当处理器被调用的时候，example\_handler函数将被调用。所有的处理器函数基本上都具有相同的样式：

static int x\_handler(request\_rec \*r)

…

Return OK;

函数具有唯一的参数request\_rec，同时函数会返回OK或者DECLINE。如果处理器成功的处理结束就返回OK。如果处理器发现不是它能处理的请求则返回DECLINE，这跟普通的挂钩完全相同。

对于example\_handler，它的主要任务就是返回给客户端固定的HTML报文。因此整个过程相对简单：

static int x\_handler(request\_rec \*r)

if (strcmp(r->handler, "example-handler")) \{

return DECLINED;

对于大部分处理器来说，尤其是类似于status\_handler，info\_handler等都需要首先判断请求中传递的处理器是否是指定的处理器。

/\*

\* We're about to start sending content, so we need to force the HTTP

\* headers to be sent at this point.  Otherwise, no headers will be sent

\* at all.  We can set any we like first, of course.  \*\*NOTE\*\* Here's

\* where you set the "Content-type" header, and you do so by putting it in

\* r->content\_type, \*not\* r->headers\_out("Content-type").   If you don't

\* set it, it will be filled in with the server's default type (typically

\* "text/plain").  You \*must\* also ensure that r->content\_type is lower

\* case.

\* We also need to start a timer so the server can know if the connexion

\* is broken.

\*/

ap\_set\_content\_type(r, "text/html");

if (r->header\_only) \{

return OK;

如果客户端仅仅需要我们返回头信息，那么我们就没有必要继续发送后面的报文体。

ap\_rputs(DOCTYPE\_HTML\_3\_2, r);

ap\_rputs("<HTML>/n", r);

ap\_rputs(" <HEAD>/n", r);

ap\_rputs("  <TITLE>mod\_example Module Content-Handler Output/n", r);

ap\_rputs("  </TITLE>/n", r);

ap\_rputs(" </HEAD>/n", r);

ap\_rputs(" <BODY>/n", r);

ap\_rputs("  <H1><SAMP>mod\_example</SAMP> Module Content-Handler Output/n", r);

ap\_rputs("  </H1>/n", r);

ap\_rputs("  <P>/n", r);

ap\_rprintf(r, "  [Apache][] HTTP Server version: /"%s/"/n",

ap\_get\_server\_version());

ap\_rputs("  <BR>/n", r);

ap\_rprintf(r, "  Server built: /"%s/"/n", ap\_get\_server\_built());

ap\_rputs("  </P>/n", r);;

ap\_rputs("  <P>/n", r);

ap\_rputs("  The format for the callback trace is:/n", r);

ap\_rputs("  </P>/n", r);

ap\_rputs("  <DL>/n", r);

ap\_rputs("   <DT><EM>n</EM>.<SAMP><routine-name>", r);

ap\_rputs("(<routine-data>)</SAMP>/n", r);

ap\_rputs("   </DT>/n", r);

ap\_rputs("   <DD><SAMP>\[<applies-to>\]</SAMP>/n", r);

ap\_rputs("   </DD>/n", r);

ap\_rputs("  </DL>/n", r);

ap\_rputs("  <P>/n", r);

ap\_rputs("  The <SAMP><routine-data></SAMP> is supplied by/n", r);

ap\_rputs("  the routine when it requests the trace,/n", r);

ap\_rputs("  and the <SAMP><applies-to></SAMP> is extracted/n", r);

ap\_rputs("  from the configuration record at the time of the trace./n", r);

ap\_rputs("  <STRONG>SVR()</STRONG> indicates a server environment/n", r);

ap\_rputs("  (blank means the main or default server, otherwise it's/n", r);

ap\_rputs("  the name of the VirtualHost); <STRONG>DIR()</STRONG>/n", r);

ap\_rputs("  indicates a location in the URL or filesystem/n", r);

ap\_rputs("  namespace./n", r);

ap\_rputs("  </P>/n", r);

ap\_rprintf(r, "  <H2>Static callbacks so far:</H2>/n  <OL>/n%s  </OL>/n",

“Test”);

ap\_rputs("  <H2>Request-specific callbacks so far:</H2>/n", r);

ap\_rputs("  <H2>Environment for <EM>this</EM> call:</H2>/n", r);

ap\_rputs(" </BODY>/n", r);

ap\_rputs("</HTML>/n", r);

return OK;

我们在前面设置的发送的内容格式是”text/html”，因此真正发送的时候我们就必须构造HTML报文。通过ap\_rputs以及ap\_rprintf函数可以将指定的字符串写入到当前的请求中。

13.11  CGI脚本

尽管在前面我们已经谈过多种内容处理器，包括default\_handler，mod\_alias等等。但是相对于CGI内容处理器而言，它们都只能算是非常简单的处理器。

在本章中我们首先描述CGI的一些基本概念，在后面的部分，我们将深入的讨论CGI处理器的实现细节。

13.11.1  CGI工作原理

CGI的工作原理非常的简单。当浏览器请求的是一个CGI脚本的时候，服务器将首先找到该文件，然后启动一个新的子进程，并在该子进程中运行该脚本文件。如果客户端需要提交额外的信息给服务器，比如POST，那么此时服务器就会通过标准输入文件描述符将请求的信息发送给脚本。反之，如果脚本执行完毕后需要返回数据给客户端浏览器，那么它也会将输出内容写入到标准输出文件描述符，然后服务器读取该内容并发送给客户。客户端，[Apache][]服务器以及CGI进程之间的关系可以用下图进行描述：

图13-

CGI脚本可以采用各种语言编写，但是大多数情况下会采用一些脚本语言，比如Perl，Python，甚至可以用Unix Shell进行编写。

13.11.2  CGI的相关配置

由于CGI属于处理器的一种，因此在使用之前必须能够对它进行配置处理，通知服务器哪些文件必须被CGI脚本处理。[Apache][]中可以通过两种途径来建立这种对应的处理关系：

（1）ScriptAlias指令

**ScriptAlias** *URL-path file-path|directory-path*

这个指令在mod\_alias模块中实现，用于映射一个URL到文件系统。该指令具有两个参数：将要用于访问这个目录的URI以及目录本身。以URL-path开头的(%已解码的)的URL会被映射到由第二个参数指定的具有完整路径名的本地文件系统中的脚本。ScriptAlias的标准配置如下：

ScriptAlias  /cgi-bin/ /usr/local/apache/cgi-bin

这意味着任何针对/cgi-bin/ URI位置中的请求都会被视为CGI脚本处理。不过这也可能会带来一个潜在的问题。比如如果一个图片文件正好位于对应的目录中，那么该图片也会被视为CGI脚本来执行。显然这是错误的做法。

（2）目录内配置CGI脚本

如果想把ScriptAlias指令的目录之外的其余目录中文件视为CGI脚本，那么可以将CGI相关的配置放到该目录对应.htacess中或者httpd.conf文件的对应的<Directory>配置段中。相关的配置命令包括：

Options命令

通过Options命令的ExecCGI参数通知服务器该目录下的文件可以视为CGI脚本

AddHandler

Options只是通知服务器该目录下的文件可以被视为CGI脚本执行，但是具体哪个文件会被视为CGI脚本，服务器还不清楚。此时还需要通过AddHandler指令在文件类型和文件处理器之间建立对应的关系，比如：AddHandler cgi-script cgi。

该指令指令所有的xxx.cgi的文件都由处理器cgi-script进行处理。大部分情况下，用户都会使用通用的.cgi扩展名称来命名他们的cgi脚本，这就允许使用简单的命令海为整个服务器配置所有的cgi脚本。

ScriptInterpreterSource

对于Unix操作系统而言，上面的两个指令足够。但是对于window还需要一个额外的ScriptInterpreterSource指令。在CGI脚本中，通常在第一行会使用\#!指令执行该脚本的解释器，比如\#!/usr/local/perl则指令使用perl解释器。不过Window并不支持\#!行，为此，[Apache][]引入了ScriptInterpreterSource指令用以指令解释器，比如：ScriptInterpreterSource registry。

该指令使得服务器将在window的注册表中去查找与指令的文件关联的处理器程序。

13.11.3 CGI脚本示例

通过上面的配置，我们现在可以运行一些CGI脚本。在运行脚本之前，我们必须能够编写脚本。我们将使用两种语言来编写脚本：C语言和Perl脚本。

13.11.3.1  Helloworld

第一个CGI脚本非常简单，就是在浏览器上输出字符串“HelloWorld”。

Perl脚本：

\#!/usr/bin/perl

print “Content-Type: text/plain/n/n”

print “Hello World/n”

C语言版本：

\#include < stdio.h >

\#include < stdib.h >

void main()

printf(″Contenttype:text/plain/n/n″);

printf("HelloWorld");

fflush(stdout);

对于脚本语言而言，需要注意的第一件事情就是指定需要调用的脚本解释器。对于Perl语言而言，大部分的Perl脚本都会使用PATH环境变量来找到Perl解释器，所以\#!/usr/bin/perl可以简化为\#!perl。这种简化方式有的时候会存在一定的问题。CGI脚本通常不会使用与常规用户相同的环境来运行。从安全的角度而言，将CGI脚本环境从Web服务器中剥离出来是个明智的选择。因此最好的办法就是指定解释器的完整的路径名称。

第二个问题就是CGI会在输出实际内容之前首先输出一些头信息。这些头信息很重要：

prinft (″Contenttype:text/plain/n/n″);

此行通过标准输出将字符串″Contenttype:text/plainnn″传送给Web服务器。它是一个MIME头信息,它告诉Web服务器随后的输出是以纯ASCII文本的形式。如果没有这个头信息，请求就会失败。当然CGI还会输出更多的信息，重要的是，脚本必须以空行终止头信息，这就是为什么用户在头信息之后会使用两个”/n”的原因。第一个”/n”用于终止内容类型(Content-Type)。HTTP协议规定头信息必须以”/n”结束。第二个”/n”用于终止头信息块。第二个”/n”之后的内容都将被认为是主体数据。

对于C语言编写的CGI，在编译通过后，将它们的后缀名称修改为.cgi，然后保存到/cgi-bin/目录中，这样第一个CGI程序就结束了。

13.11.3.2  输出当前的所有环境变量

下面的例子用于在浏览器中输出服务器中所有的环境变量的信息：

Perl脚本版本：

\#!/usr/bin/perl

print “Content-Type: text/plain/n/n”;

foreach $var(sort(keys(%ENV)))\{

$val = $ENV($var\};

$val =~ s|/n|//n|g;

$val =~ s|"|//"|g;

print "$s\{var\} = /"$\{var\}/"/n";

C语言版本：

\#include<stdio.h>

extern   char   \*\*environ;

int main(int  argc, int \*\*argv)

int i;

if( environ !=  NULL)

for (i = 0; environ\[i\] != NULL; i++)

printf("%s/n",   environ\[i\]);

return   0;

13.11.4 配置CGI处理器

13.11.5 mod\_cgi模块分析

本章的最后部分我们将分析cgi处理器的实现细节。cgi处理器在模块mod\_cgi中实现。

13.11.5.1  模块结构

module AP\_MODULE\_DECLARE\_DATA cgi\_module =

STANDARD20\_MODULE\_STUFF,

NULL,                        /\* dir config creater \*/

NULL,                        /\* dir merger --- default is to override \*/

create\_cgi\_config,           /\* server config \*/

merge\_cgi\_config,             /\* merge server config \*/

cgi\_cmds,                    /\* command apr\_table\_t \*/

\};

mod\_cgi是一个常规的Apache2.0模块。这里没有目录配置指令，所有两个目录配置挂钩函数都被设置为NULL。不过这边有服务器相关的指令，而且继承规则也不简单，所以需要一个创建函数和一个合并函数。

cgi\_cmds中定义了该模块能够处理的所有的命令：

static const command\_rec cgi\_cmds\[\] =

AP\_INIT\_TAKE1("**ScriptLog**", set\_scriptlog, NULL, RSRC\_CONF,

"the name of a log for script debugging info"),

AP\_INIT\_TAKE1("**ScriptLogLength**", set\_scriptlog\_length, NULL, RSRC\_CONF,

"the maximum length (in bytes) of the script debug log"),

AP\_INIT\_TAKE1("**ScriptLogBuffer**", set\_scriptlog\_buffer, NULL, RSRC\_CONF,

"the maximum size (in bytes) to record of a POST request"),

\{NULL\}

\};

mod\_cgi模块本身需要处理的三个指令都是跟CGI日志相关的。对于web服务器而言最难诊断的内容之一就是CGI脚本。为了帮助诊断CGI脚本，[Apache][]中提供了上面的三个指令。ScriptLog定义CGI日志文件；ScriptLogLength则定义了CGI日志文件的最大，当日志长度达到这个最大长度的时候，服务器就会停止写入CGI脚本的日志信息。ScriptBuffer则定义了能够记录到文件的PUT或者POST的请求主体的长度。

mod\_cgi中关心的挂钩都在register\_hooks中注册：

static void register\_hooks(apr\_pool\_t \*p)

static const char \* const aszPre\[\] = \{ "mod\_include.c", NULL \};

ap\_hook\_handler(cgi\_handler, NULL, NULL, APR\_HOOK\_MIDDLE);

ap\_hook\_post\_config(cgi\_post\_config, aszPre, NULL, APR\_HOOK\_REALLY\_FIRST);

针对这个模块的挂钩函数非常简单，一个就是内容处理器，负责生成内容；另外一个就是 post\_config挂钩，用于在处理完配置文件之后进行调用。Post\_config会使用mod\_include模块注册一个函数，因此它必须在mod\_include之后才能被调用。

13.11.5.2  处理器函数

处理器函数在每次CGI请求的时候会被调用，这个函数相对非常的复杂。我们需要逐步分析它。

static int cgi\_handler(request\_rec \*r)

int nph;

apr\_size\_t dbpos = 0;

const char \*argv0;

const char \*command;

const char \*\*argv;

char \*dbuf = NULL;

apr\_file\_t \*script\_out = NULL, \*script\_in = NULL, \*script\_err = NULL;

apr\_bucket\_brigade \*bb;

apr\_bucket \*b;

int is\_included;

int seen\_eos, child\_stopped\_reading;

apr\_pool\_t \*p;

cgi\_server\_conf \*conf;

apr\_status\_t rv;

cgi\_exec\_info\_t e\_info;

conn\_rec \*c = r->connection;

在深入进一步分析之前，我们需要对一些数据结构进行深入的了解：

第一个需要分析的是cgi\_exec\_info\_t结构：

typedef struct \{

apr\_int32\_t          in\_pipe;

apr\_int32\_t          out\_pipe;

apr\_int32\_t          err\_pipe;

int                  process\_cgi;

apr\_cmdtype\_e        cmd\_type;

apr\_int32\_t          detached;

prog\_types           prog\_type;

apr\_bucket\_brigade \*\*bb;

include\_ctx\_t       \*ctx;

ap\_filter\_t         \*next;

apr\_int32\_t          addrspace;

\} cgi\_exec\_info\_t;

CGI处理器中重要的一个工作就是建立一个子进程单独处理CGI脚本的内容。上面的结构用于帮助建立子进程的结构。这个结构中的大部分字段都可以告诉服务器如何建立子进程。前三个字段xxx\_pipe会通知服务器要将哪些标准文件描述符与管道相连接。当启动子进程的时候，服务器就会将管道与读取内容的标准输出文件描述符，以及向脚本传递信息的标准输入文件描述符进行关联。实际的问题是，管道是否应该与错误文件描述符进行关联。

cmd\_type告诉速服务器这是脚本还是已经编译好的程序。它的取值类型为apr\_cmdtype\_e：

typedef enum \{

APR\_SHELLCMD,           /\*\*< use the shell to invoke the program \*/

APR\_PROGRAM,            /\*\*< invoke the program directly, no copied env \*/

APR\_PROGRAM\_ENV,        /\*\*< invoke the program, replicating our environment \*/

APR\_PROGRAM\_PATH,       /\*\*< find program on PATH, use our environment \*/

APR\_SHELLCMD\_ENV        /\*\*< use the shell to invoke the program,

\*   replicating our environment

\*/

\} apr\_cmdtype\_e;

对于大部分操作系统而言，这没有什么用。但是在某些操作系统上，比如Window，如果不具有\#!的逻辑，而且还是脚本的话，那么[Apache][]就会实现这个逻辑。

prog\_type用以描述为什么要将这个模块作为CGI脚本直接调用，活着调用它进行SSL处理。prog\_type也是被定义为枚举类型：

typedef enum \{RUN\_AS\_SSI, RUN\_AS\_CGI\} prog\_types;

ctx和next两个成员用于mod\_include模块，目前我们可以忽略它们。

if(strcmp(r->handler, CGI\_MAGIC\_TYPE) && strcmp(r->handler, "cgi-script"))

return DECLINED;

所有的处理器都必须完成的第一件事情就是确保这个请求是针对该处理器的。通过检查请求结构中的处理器字段来完成。在Apache1.3版本中，这个检查过程是没有必要的，因为核心只会调用与这个请求相匹配的处理器。如果要编写处理器，则通常必须包含类似的该行，否则模块就会尝试为所有接收到的请求提供服务。

is\_included = !strcmp(r->protocol, "INCLUDED");

p = r->main ? r->main->pool : r->pool;

argv0 = apr\_filepath\_name\_get(r->filename);

nph = !(strncmp(argv0, "nph-", 4));

conf = ap\_get\_module\_config(r->server->module\_config, &cgi\_module);

if (!(ap\_allow\_options(r) & OPT\_EXECCGI) && !is\_scriptaliased(r))

return log\_scripterror(r, conf, HTTP\_FORBIDDEN, 0,

"Options ExecCGI is off in this directory");

上面的代码检查指定的目录是否已经允许运行CGI脚本，正如前面所言，如果某个目录允许执行CGI脚本，则它的Options指令中必须设置ExecCGI选项。如果在ScriptAlias命令中使用了这个目录，那么就可以认为CGI脚本已经在该目录中受到执行许可。

if (nph && is\_included)

return log\_scripterror(r, conf, HTTP\_FORBIDDEN, 0,

"attempt to include NPH CGI script");

在理解上面的两行代码之前，我们有必要稍微了解一下NPH CGI脚本的概念。

此处需要补充CGI的相关内容

if (r->finfo.filetype == 0)

return log\_scripterror(r, conf, HTTP\_NOT\_FOUND, 0,

"script not found or unable to stat");

if (r->finfo.filetype == APR\_DIR)

return log\_scripterror(r, conf, HTTP\_FORBIDDEN, 0,

"attempt to invoke directory as script");

if ((r->used\_path\_info == AP\_REQ\_REJECT\_PATH\_INFO) &&

r->path\_info && \*r->path\_info)

/\* default to accept \*/

return log\_scripterror(r, conf, HTTP\_NOT\_FOUND, 0,

"AcceptPathInfo off disallows user's path");

上面的代码用于对请求的脚本的路径信息进行检查。需要请求的CGI脚本的信息保存在请求r->finfo中。如果r->finfo.filetype为零，则意味着没有指定CGI脚本的路径。如果指定的CGI脚本路径是目录名称，则这也是不允许的。

大部分情况下，请求所映射的脚本的路径名称都是在磁盘上存在实际文件的。不过也有例外，那就是AcceptInfoPath指令所处理的内容。此指令决定了是否接受包含在某确定文件(或是某现有目录的一个不存在的文件)后附加的路径信息。此路径信息将在脚本里以PATH\_INFO环境变量的形式出现。

比如说，假设/test/所指向的目录下只包括一个文件：here.html。那么对/test/here.html/more和/test/nothere.html/more的请求都会得到/more这样的PATH\_INFO变量。

AcceptPathInfo指令的三个参数为：

1.     off

仅当一个请求映射到一个真实存在的路径时，它才会被接受。这样，如上述/test/here.html/more这样的在真实文件名后跟随一个路径名的请求将会返回一个404 NOT FOUND错误。[Apache][]中使用宏**AP\_REQ\_REJECT\_PATH\_INFO**来对应该值。

2.     on

如果前面的路径映射到一个真实存在的文件，此请求将被接受。如果/test/here.html映射着一个有效的文件，上例中/test/here.html/more这个请求就会被接受。[Apache][]中使用**AP\_REQ\_ACCEPT\_PATH\_INFO**宏来定义该值。

3.     default

对于附加路径名的请求的处理方式由其对应的[处理器][Link 1]来决定。对应普通文本的核心处理器默认会拒绝PATH\_INFO。而用于伺服脚本的处理器，比如[cgi-script][]和[isapi-isa][]，默认会接受PATH\_INFO。[Apache][]中使用AP\_REQ\_DEFAULT\_PATH\_INFO定义该值。

AcceptPathInfo指令存在的首要目的就是允许您覆盖处理器关于是否接受PATH\_INFO的默认设置。这种覆盖是很必要的。比如说，当您使用了类似[INCLUDES][]这样的[过滤器][Link 2]来根据PATH\_INFO产生内容时。核心处理器通常会拒绝这样的请求，而您就可以用下述的配置使这样的脚本成为可能：

Options +Includes

SetOutputFilter INCLUDES

AcceptPathInfo on

</Files>

AcceptPathInfo指令的参数最终会保存到r->used\_path\_info成员中，而PATH\_INFO环境变量的值则会用r->path\_info进行记录。如果当前服务器不支持附加路径信息，即r->used\_path\_info == AP\_REQ\_REJECT\_PATH\_INFO，但是r->path\_info不为空，那么则意味着URI中添加了附加路径信息。这种情况是不允许的。

ap\_add\_common\_vars(r);

ap\_add\_cgi\_vars(r);

为了执行CGI脚本进行，我们还必须进行必要的环境变量设置。这下变量包括公共的CGI脚本环境变量和HTTP1.1所需要的CGI环境变量。公共的CGI环境变量包括SystemRoot，COMSPEC等等。而HTTP1.1相关的CGI环境变量则包括SCRIPT\_NAME，PATH\_INFO等等。具体的设置细节我们稍后讨论。

e\_info.process\_cgi = 1;

e\_info.cmd\_type    = APR\_PROGRAM;

e\_info.detached    = 0;

e\_info.in\_pipe     = APR\_CHILD\_BLOCK;

e\_info.out\_pipe    = APR\_CHILD\_BLOCK;

e\_info.err\_pipe    = APR\_CHILD\_BLOCK;

e\_info.prog\_type   = RUN\_AS\_CGI;

e\_info.bb          = NULL;

e\_info.ctx         = NULL;

e\_info.next        = NULL;

e\_info.addrspace   = 0;

/\* build the command line \*/

if ((rv = cgi\_build\_command(&command, &argv, r, p, &e\_info)) != APR\_SUCCESS) \{

ap\_log\_rerror(APLOG\_MARK, APLOG\_ERR, rv, r,

"don't know how to spawn child process: %s",

r->filename);

return HTTP\_INTERNAL\_SERVER\_ERROR;

在建立CGI进程执行脚本之前，必须建立能够启动CGI脚本的命令行。这要使用cgi\_build\_command函数完成。

/\* run the script in its own process \*/

if ((rv = run\_cgi\_child(&script\_out, &script\_in, &script\_err,

command, argv, r, p, &e\_info)) != APR\_SUCCESS) \{

ap\_log\_rerror(APLOG\_MARK, APLOG\_ERR, rv, r,

"couldn't spawn child process: %s", r->filename);

return HTTP\_INTERNAL\_SERVER\_ERROR;

最后run\_cgi\_child函数将真正启动一个新的CGI进行处理CGI脚本。在稍后的部分，我们会分析启动进程的细节。

/\* Transfer any put/post args, CERN style...

\* Note that we already ignore SIGPIPE in the core server.

\*/

bb = apr\_brigade\_create(r->pool, c->bucket\_alloc);

seen\_eos = 0;

child\_stopped\_reading = 0;

if (conf->logname) \{

dbuf = apr\_palloc(r->pool, conf->bufbytes + 1);

dbpos = 0;

do \{

apr\_bucket \*bucket;

rv = ap\_get\_brigade(r->input\_filters, bb, AP\_MODE\_READBYTES,

APR\_BLOCK\_READ, HUGE\_STRING\_LEN);

if (rv != APR\_SUCCESS) \{

return rv;

for (bucket = APR\_BRIGADE\_FIRST(bb);

bucket != APR\_BRIGADE\_SENTINEL(bb);

bucket = APR\_BUCKET\_NEXT(bucket))

const char \*data;

apr\_size\_t len;

if (APR\_BUCKET\_IS\_EOS(bucket)) \{

seen\_eos = 1;

break;

/\* We can't do much with this. \*/

if (APR\_BUCKET\_IS\_FLUSH(bucket)) \{

continue;

/\* If the child stopped, we still must read to EOS. \*/

if (child\_stopped\_reading) \{

continue; 

/\* read \*/

apr\_bucket\_read(bucket, &data, &len, APR\_BLOCK\_READ);

if (conf->logname && dbpos < conf->bufbytes) \{

int cursize;

if ((dbpos + len) > conf->bufbytes) \{

cursize = conf->bufbytes - dbpos;

else \{

cursize = len;

memcpy(dbuf + dbpos, data, cursize);

dbpos += cursize;

/\* Keep writing data to the child until done or too much time

\* elapses with no progress or an error occurs.

\*/

rv = apr\_file\_write\_full(script\_out, data, len, NULL);

if (rv != APR\_SUCCESS) \{

/\* silly script stopped reading, soak up remaining message \*/

child\_stopped\_reading = 1;

apr\_brigade\_cleanup(bb);

while (!seen\_eos);

上面的代码将从客户端读取信息，并将其发到给CGI脚本，以便对其进行处理。读取按照正常的存储段组的读取操作进行。不过有一种情况我们必须考虑到，那就是万一CGI进程停止了读取过程。在上面的代码中，child\_stopped\_reading用来标记CGI进程是否停止报文读取。任何时候如果调用apr\_file\_write\_full向CGI进程写入数据导致失败的时候，child\_stopped\_reading都会被设置。

如果CGI脚本停止从服务器读取信息，那么此时读取进程并不能停止从客户端读取信息。这样做就会违反HTTP规范。为了处理这种情况，需要设置一个循环，该循环从客户端读取数据。如果CGI进程停止读取，那么这些数据将被简单的抛弃，直到所有的客户端数据读取完毕。这就是Œ处代码的作用。

if (conf->logname) \{

dbuf\[dbpos\] = '/0';

/\* Is this flush really needed? \*/

apr\_file\_flush(script\_out);

apr\_file\_close(script\_out);

AP\_DEBUG\_ASSERT(script\_in != NULL);

apr\_brigade\_cleanup(bb);

\#if APR\_FILES\_AS\_SOCKETS

apr\_file\_pipe\_timeout\_set(script\_in, 0);

apr\_file\_pipe\_timeout\_set(script\_err, 0);

b = cgi\_bucket\_create(r, script\_in, script\_err, c->bucket\_alloc);

\#else

b = apr\_bucket\_pipe\_create(script\_in, c->bucket\_alloc);

\#endif

APR\_BRIGADE\_INSERT\_TAIL(bb, b);

b = apr\_bucket\_eos\_create(c->bucket\_alloc);

APR\_BRIGADE\_INSERT\_TAIL(bb, b);

将数据写入给CGI进程之后，CGI进程将开始执行。执行后的数据通过sript\_in管道再返回给[Apache][]服务器。在接受服务器的返回之前，服务器必须分配足够的空间一边保存这些数据。由于所有的数据都是通过script\_xxx管道进行的，为此服务器将创建一个存储段组，其中包含一个管道存储段和一个EOS存储段。

/\* Handle script return... \*/

if (!nph) \{

const char \*location;

char sbuf\[MAX\_STRING\_LEN\];

int ret;

if ((ret = ap\_scan\_script\_header\_err\_brigade(r, bb, sbuf))) \{

ret = log\_script(r, conf, ret, dbuf, sbuf, bb, script\_err);

/\* Set our status. \*/ŒŽ

r->status = ret;

/\* Pass EOS bucket down the filter chain. \*/

apr\_brigade\_cleanup(bb);

b = apr\_bucket\_eos\_create(c->bucket\_alloc);

APR\_BRIGADE\_INSERT\_TAIL(bb, b);

ap\_pass\_brigade(r->output\_filters, bb);

return ret;

上面的代码用于处理CGI脚本的输出。不过对于nph脚本和非nph脚本的返回处理不同。对于非nph脚本而言，当CGI脚本开始返回消息的时候，必须确保该信息有效。返回的数据中必须包含相关的头信息，如果没有，那么就必须记录错误的信息，并将错误信息发送给服务器。

location = apr\_table\_get(r->headers\_out, "Location");

if (location && r->status == 200) \{

/\* For a redirect whether internal or not, discard any

\* remaining stdout from the script, and log any remaining

\* stderr output, as normal. \*/

discard\_script\_output(bb);

apr\_brigade\_destroy(bb);

apr\_file\_pipe\_timeout\_set(script\_err, r->server->timeout);

log\_script\_err(r, script\_err);

if (location && location\[0\] == '/' && r->status == 200) \{

/\* This redirect needs to be a GET no matter what the original

\* method was.

\*/

r->method = apr\_pstrdup(r->pool, "GET");

r->method\_number = M\_GET;

/\* We already read the message body (if any), so don't allow

\* the redirected request to think it has one.  We can ignore

\* Transfer-Encoding, since we used REQUEST\_CHUNKED\_ERROR.

\*/

apr\_table\_unset(r->headers\_in, "Content-Length");

ap\_internal\_redirect\_handler(location, r);

return OK;

第二个可能从CGI脚本中返回的值是位置头(Location header)，它告诉服务器，CGI脚本正在发出到另外的URI的重定向。为了处理这种情况，服务器需要从CGI脚本中读取所有的剩余的数据，并进行内部重定向。内部重定向将意味着客户将不能够看到响应。核心服务器会完成所有的工作，并且向客户端返回正确的页面。

else if (location && r->status == 200) \{

/\* XX Note that if a script wants to produce its own Redirect

\* body, it now has to explicitly \*say\* "Status: 302"

\*/

return HTTP\_MOVED\_TEMPORARILY;

rv = ap\_pass\_brigade(r->output\_filters, bb);

if (nph) \{

struct ap\_filter\_t \*cur;

/\* get rid of all filters up through protocol...  since we

\* haven't parsed off the headers, there is no way they can

\* work

\*/

cur = r->proto\_output\_filters;

while (cur && cur->frec->ftype < AP\_FTYPE\_CONNECTION) \{

cur = cur->next;

r->output\_filters = r->proto\_output\_filters = cur;

bb = apr\_brigade\_create(r->pool, c->bucket\_alloc);

b = apr\_bucket\_pipe\_create(tempsock, c->bucket\_alloc);

APR\_BRIGADE\_INSERT\_TAIL(bb, b);

b = apr\_bucket\_eos\_create(c->bucket\_alloc);

APR\_BRIGADE\_INSERT\_TAIL(bb, b);

ap\_pass\_brigade(r->output\_filters, bb);

return OK; /\* NOT r->status, even if it has changed. \*/

13.11.5.3  CGI命令行构建

在了解了处理器函数的执行细节之后，我们对整个流程有一个完整的了解，不过对于一些细节，我们还有待挖掘。首先我们来看CGI进程启动的命令行的构建过程。

通常情况下CGI进程通常是一个相对独立的可执行进程，为了启动该进程，服务器必须对启动的命令行进行构建，构建使用函数cgi\_build\_command完成：

cgi\_build\_comand被声明为可选挂钩函数类型：

static APR\_OPTIONAL\_FN\_TYPE(ap\_cgi\_build\_command) \*cgi\_build\_command;

它对应的可选挂钩函数为ap\_cgi\_build\_command，该函数在mod\_cgi.h中被声明：

APR\_DECLARE\_OPTIONAL\_FN(apr\_status\_t, ap\_cgi\_build\_command,

(const char \*\*cmd, const char \*\*\*argv,

request\_rec \*r, apr\_pool\_t \*p,

cgi\_exec\_info\_t \*e\_info));

该可选挂钩返回apr\_status\_t类型，而且需要五个参数。任何模块如果需要使用该函数，它都可以注册该函数，比如

APR\_REGISTER\_OPTIONAL\_FN(ap\_cgi\_build\_command);

同样，服务器如果需要使用该函数，他也必须首先获取该函数的指针，比如：

cgi\_build\_command    = APR\_RETRIEVE\_OPTIONAL\_FN(ap\_cgi\_build\_command);

在大部分系统平台上，ap\_cgi\_build\_command都不需要额外注册实现，它们都使用默认的命令行构建函数default\_build\_command，而对于window平台和netware平台而言，则由于存在一些差异性，必须使用它们自己的命令行构建函数。

13.11.5.4  生成CGI进程

在创建生成完需要执行的命令行之后，我们就可以启动该CGI进程了。[Apache][]核心使用函数run\_cgi\_child函数创建一个新的CGI进程，该函数的原型如下：

static apr\_status\_t run\_cgi\_child(apr\_file\_t \*\*script\_out,

apr\_file\_t \*\*script\_in,

apr\_file\_t \*\*script\_err,

const char \*command,

const char \* const argv\[\],

request\_rec \*r,

apr\_pool\_t \*p,

cgi\_exec\_info\_t \*e\_info)

函数具有多达八个参数。srcipt\_xxx是三个管道，用于服务器和CGI进程之间的通信。script\_out用于从服务器输出数据至CGI进程，script\_in则用于CGI进程返回数据至服务器进程。script\_err则用于CGI进程返回错误信息至服务器。

command则是用于启动进程的命令行，argv则是对应的命令行参数。

const char \* const \*env;

apr\_procattr\_t \*procattr;

apr\_proc\_t \*procnew;

apr\_status\_t rc = APR\_SUCCESS;

\#if defined(RLIMIT\_CPU)  || defined(RLIMIT\_NPROC) || /

defined(RLIMIT\_DATA) || defined(RLIMIT\_VMEM) || defined (RLIMIT\_AS)

core\_dir\_config \*conf = ap\_get\_module\_config(r->per\_dir\_config,

&core\_module);

\#endif

在有些操作系统平台上，为了防止一些恶意的进程，系统允许对进程的执行做一些限制。通过getrlimit和setrlimit可以获取和设置这些限制。

RLIMIT\_CPU：程序执行的最大CPU时间，单位是秒。超过之后程序中止，中止的信号是SIGXCPU

RLIMIT\_DATA：进程中所能允许分配的堆栈的最大时间。

RLIMIT\_NPROC：程序允许产生的最大子进程数量

RLIMIT\_VMEM和RLIMIT\_AS的含义类似，定义限制说明一个进程的映射地址空间可以占据的字节数。如果超出限制，分配动态内存和到mmap的调用会失败。

只有当OS中定义了上面的RLIMIT\_XXX指令之后，才会执行上面的代码。[Apache][]中通过配置文件对进程进行各种限制，这些指令包括RLimitCPU，RLimitMEM，RLimitNPROC等等。如果需要进行这种处理，那么服务器就会从核心中读取配置信息

if (((rc = apr\_procattr\_create(&procattr, p)) != APR\_SUCCESS) ||

((rc = apr\_procattr\_io\_set(procattr,

e\_info->in\_pipe,

e\_info->out\_pipe,

e\_info->err\_pipe)) != APR\_SUCCESS) ||

((rc = apr\_procattr\_dir\_set(procattr,

ap\_make\_dirstr\_parent(r->pool,

r->filename))) != APR\_SUCCESS) ||

\#ifdef RLIMIT\_CPU

((rc = apr\_procattr\_limit\_set(procattr, APR\_LIMIT\_CPU,

conf->limit\_cpu)) != APR\_SUCCESS) ||

\#endif

\#if defined(RLIMIT\_DATA) || defined(RLIMIT\_VMEM) || defined(RLIMIT\_AS)

((rc = apr\_procattr\_limit\_set(procattr, APR\_LIMIT\_MEM,

conf->limit\_mem)) != APR\_SUCCESS) ||

\#endif

\#ifdef RLIMIT\_NPROC

((rc = apr\_procattr\_limit\_set(procattr, APR\_LIMIT\_NPROC,

conf->limit\_nproc)) != APR\_SUCCESS) ||

\#endif

((rc = apr\_procattr\_cmdtype\_set(procattr,

e\_info->cmd\_type)) != APR\_SUCCESS) ||

((rc = apr\_procattr\_detach\_set(procattr,

e\_info->detached)) != APR\_SUCCESS) ||

((rc = apr\_procattr\_addrspace\_set(procattr,

e\_info->addrspace)) != APR\_SUCCESS) ||

((rc = apr\_procattr\_child\_errfn\_set(procattr, cgi\_child\_errfn)) != APR\_SUCCESS)) \{

/\* Something bad happened, tell the world. \*/

ap\_log\_rerror(APLOG\_MARK, APLOG\_ERR, rc, r,

"couldn't set child process attributes: %s", r->filename);

上面的代码首先会调用apr\_procattr\_create函数创建一个属性描述数据结构procattr，并对CGI脚本的进行属性进行设置。这些进程信息包括进程在运行时候所处的目录，与管道相关联的文件描述符，以及系统中对进程运行的各种限制。

[Apache]: http://httpd.apache.org/
[Link 1]: http://www.7880.com/Manual/ApacheManual_GB/handler.html
[cgi-script]: http://www.7880.com/Manual/ApacheManual_GB/mod/mod_cgi.html
[isapi-isa]: http://www.7880.com/Manual/ApacheManual_GB/mod/mod_isapi.html
[INCLUDES]: http://www.7880.com/Manual/ApacheManual_GB/mod/mod_include.html
[Link 2]: http://www.7880.com/Manual/ApacheManual_GB/filter.html