apache模块开发之挂钩、可选函数和过滤器

心已赠人 2021-06-24 13:59 207阅读 0赞

## **前言** ##

建议直接参考我总结的word文档，[点击下载][Link 1]

tomcat和apache (httpd server)是两种web网络服务器程序，当用户通过浏览器访问服务器上时，两者都可以对用户发来的请求进行解析并返回结果。但两者在应用程序开发上还是有区别：

tomcat：具有容器性质，开发者根据用户需求而开发的java Web服务程序需要被包含在tomcat中，由tomcat对开发者的程序并结合tomcat自身进行解析用户请求，从这个方面来说，tomcat应该称得上是一种具有容器功能的web网络服务器；

apache httpd server：模块化设计，开发者根据用户需求开发出各个需求功能模块并加载到apache中，这些模块可以任意的加载与卸载。

## **一．挂钩使用** ##

在Apache中挂钩hook共可分为三类：自定义挂钩、标准挂钩和可选挂钩，下面逐一介绍下这三类挂钩的使用方法。

**1．自定义挂钩的使用步骤：**

**1、声明**

\#define AP\_DECLARE\_HOOK(ret,name,args) /

APR\_DECLARE\_EXTERNAL\_HOOK(ap,AP,ret,name,args)

即,使用宏AP\_DECLARE\_HOOK或APR\_DECLARE\_EXTERNAL\_HOOK来声明一个挂钩,该声明宏展开后是五个函数：挂钩的执行函数、挂钩的注册函数、挂钩的调用函数、返回挂钩函数链的函数以及函数链节点结构。

以post\_config挂钩为例,展开后的五个函数分别为：

执行函数：ap\_HOOK\_post\_config\_t

注册函数：ap\_hook\_post\_config

调用函数：ap\_run\_post\_config

获取函数链：AP\_DECLARE (apr\_array\_header\_t \*) ap\_hook\_get\_post\_config(void)

typedef struct ap\_LINK\_post\_config\_t

ap\_HOOK\_post\_config\_t \*pFunc;

const char \*szName;

const char \* const \*aszPredecessors;

const char \* const \*aszSuccessors;

int nOrder;

\} ap\_LINK\_post\_config\_t;

**2、添加**

挂钩结构体APR\_HOOK\_STRUCT中包含了当前模块的所有挂钩，因此，我们需要将自己定义的挂钩添加到该结构体中。比如在第一步中我们声明了如下的挂钩AP\_DECLARE\_HOOK(int,some\_hook,(request\_rec\* r,int n))，则

APR\_HOOK\_STRUCT(

APR\_HOOK\_LINK(some\_hook)

……

)

**3、实现**

在上面的第一步中声明了五个函数，在这一步中要实现其中的两个函数：注册函数和调用函数，其中

宏APR\_IMPLEMENT\_EXTERNAL\_HOOK\_BASE实现了挂钩的注册函数，以post\_config挂钩为例，该宏展开的结果如下：

AP\_DECLARE(int) ap\_hook\_post\_config(ap\_HOOK\_post\_config\_t \*pf,

const char \* const \*aszPre,

const char \* const \*aszSucc,

int nOrder)

ap\_LINK\_post\_config\_t \*pHook;

if (!\_hooks.link\_post\_config) \{

\_hooks.link\_post\_config = apr\_array\_make(apr\_hook\_global\_pool,1，sizeof(ap\_LINK\_post\_config\_t));

apr\_hook\_sort\_register("post\_config", &\_hooks.link\_post\_config);

pHook = apr\_array\_push(\_hooks.link\_post\_config);

pHook->pFunc = pf;

pHook->aszPredecessors = aszPre;

pHook->aszSuccessors = aszSucc;

pHook->nOrder = nOrder;

pHook->szName = apr\_hook\_debug\_current;

if (apr\_hook\_debug\_enabled)

apr\_hook\_debug\_show("post\_config", aszPre, aszSucc);

AP\_DECLARE(apr\_array\_header\_t \*) ap\_hook\_get\_post\_config(void) \{

return \_hooks.link\_post\_config;

从上面的展开结果中我们可以很清楚的看出APR\_IMPLEMENT\_EXTERNAL\_HOOK\_BASE宏实现了我们所需要的挂钩注册函数以及挂钩信息获取函数。

下面三个宏AP\_IMPLEMENT\_HOOK\_VOID、AP\_IMPLEMENT\_HOOK\_RUN\_FIRST以及 AP\_IMPLEMENT\_HOOK\_RUN\_ALL实现了挂钩的调用函数，以AP\_IMPLEMENT\_HOOK\_VOID为例展开：

\#define APR\_IMPLEMENT\_EXTERNAL\_HOOK\_VOID(ns,link,name,args\_decl,args\_use) /

APR\_IMPLEMENT\_EXTERNAL\_HOOK\_BASE(ns,link,name) /

link\#\#\_DECLARE(void) ns\#\#\_run\_\#\#name args\_decl /

\{ /

ns\#\#\_LINK\_\#\#name\#\#\_t \*pHook; /

int n; /

if(!\_hooks.link\_\#\#name) /

return; /

pHook=(ns\#\#\_LINK\_\#\#name\#\#\_t \*)\_hooks.link\_\#\#name->elts; /

for(n=0 ; n < \_hooks.link\_\#\#name->nelts ; ++n) /

pHook\[n\].pFunc args\_use; /

从上面我们可以看到，在APR\_IMPLEMENT\_EXTERNAL\_HOOK\_VOID宏中已经包含了宏APR\_IMPLEMENT\_EXTERNAL\_HOOK\_BASE，即该宏同时实现了挂钩的注册函数和调用函数。

**4、关联**

将挂钩函数与挂钩通过挂钩的注册函数ap\_hook\_test\_hook(test\_hook\_func,NULL,NULL,APR\_HOOK\_MIDDLE);

\[其中，test\_hook挂钩的名字，test\_hook\_func该挂钩的挂钩函数\]进行关联并通过模块的注册函数register\_hooks(apr\_pool\_t \*p)注册到模块内。

**5、调用**

一旦各个模块在挂钩数组中注册了自己感兴趣的挂钩，那么剩下的事情无非就是调用这些挂钩，实际上也就是最终调用挂钩对应的函数。Apache中的挂钩调用函数形式通常如ap\_run\_HOOKNAME所 示，比如ap\_run\_post\_config就是调用post\_config挂钩。

**2．标准挂钩的使用步骤：**

Apache本身实现了部分挂钩，这些由apache自身实现的挂钩在调用时直接在module结构体的注册挂钩函数中调用挂钩的注册函数即可，以mod\_status模块中的标准挂钩handler和post\_config为例：

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

/\* handler与post\_config是apache定义的标准挂钩；test\_hook是用户自定义的普通挂钩;optional\_hook是用户自定义的可选挂钩 \*/

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

/\* status\_init是post\_config挂钩的挂钩函数(挂钩的执行函数),ap\_hook\_post\_config是挂钩的注册函数 \*/

ap\_hook\_post\_config(status\_init, NULL, NULL, APR\_HOOK\_MIDDLE);

/\* Optional hook 将可选挂钩添加到apache内核的全局可选挂钩哈希表中 \*/

APR\_OPTIONAL\_HOOK(ap, optional\_hook,optional\_hook\_func,NULL,NULL,APR\_HOOK\_MIDDLE);

/\* No-optional hook 普通挂钩的注册函数 \*/

ap\_hook\_test\_hook(test\_hook\_func,NULL,NULL,APR\_HOOK\_MIDDLE);

\#ifdef HAVE\_TIMES

ap\_hook\_child\_init(status\_child\_init, NULL, NULL, APR\_HOOK\_MIDDLE);

\#endif

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

STANDARD20\_MODULE\_STUFF,

NULL,                       /\* dir config creater \*/

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

NULL,                       /\* server config \*/

NULL,                       /\* merge server config \*/

status\_module\_cmds,         /\* command table \*/

\};

**3．可选挂钩的使用步骤：**

**1、声明**

可选挂钩的声明方法与标准挂钩声明没有任何区别，都是通过AP\_DECLARE\_HOOK进行的，比如下面的语句声明一个可选挂钩：

AP\_DECLARE\_HOOK(int , optional\_hook , (request\_rec \*r , int n))

与标准挂钩相比，可选挂钩没有内部私有的数据结构。在标准挂钩中，为了保存各个模块对声明的挂钩的使用情况，通过声明AP\_HOOK\_STRUCT结构来实现。这种做法实际上是由挂钩实现者自行进行维护；而对于可选挂钩，模块编写者可以不需要维护该AP\_HOOK\_STRUCT结构了，该结构则转交内核维护。

**2、添加**

对于可选挂钩，由于不存在AP\_HOOK\_STRUCT宏，因此也就不存在挂钩数组了。在前面我们提到过，可选挂钩的保存是由Apache内核维护的，在Apache内部，内核定义了两个全局哈希表s\_phOptionalHooks和s\_phOptionalFunctions分别保存所有的可选挂钩以及对应的挂钩处理句柄。S\_phOptionalHooks哈希表中，可选挂钩名称用来作为哈希表Key键，而挂钩对应的挂钩数组则作为哈希表的Value值。我们展开宏APR\_OPTIONAL\_HOOK就知道了。

APR\_OPTIONAL\_HOOK宏定义在ap\_optional\_hooks.h中：

\#define APR\_OPTIONAL\_HOOK(ns,name,pfn,aszPre,aszSucc,nOrder) do \{ \\

ns\#\#\_HOOK\_\#\#name\#\#\_t \*apu\_\_hook = pfn; \\

apr\_optional\_hook\_add(\#name,(void (\*)(void))apu\_\_hook,aszPre, aszSucc, nOrder); \\

\} while (0)

由该宏我们可以得知，该宏将可选挂钩添加到了内核的可选挂钩哈希表中。

**3、实现**

在实现上，可选挂钩的声明从标准挂钩的AP\_IMPLEMENT\_HOOK\_RUN\_ALL形式转变为AP\_IMPLEMENT\_OPTIONAL\_HOOK\_RUN\_ALL，而且没有AP\_IMPLEMENT\_OPTIONAL\_HOOK\_RUN\_VOID和AP\_IMPLEMENT\_OPTIONAL\_HOOK\_RUN\_FIRST这两个宏。同时要注意，与非可选挂钩的AP\_IMPLEMENT\_HOOK\_RUN\_ALL相比，可选挂钩的AP\_IMPLEMENT\_OPTIONAL\_HOOK\_RUN\_ALL仅仅实现了挂钩的调用函数而没有同时实现挂钩的注册函数。

**4、关联**

对于可选挂钩，其关联同上面第二步的添加操作所用的是同一个宏，即：将挂钩函数与挂钩通过APR\_OPTIONAL\_HOOK(ap, optional\_hook,optional\_hook\_func,NULL,NULL,APR\_HOOK\_MIDDLE);

\[其中，optional\_hook挂钩的名字，optional\_hook\_func该挂钩的挂钩函数\]进行关联并通过模块的注册函数register\_hooks(apr\_pool\_t \*p)注册到apache的内核中。

**5、调用**

调用同标准挂钩，调用ap\_run\_HOOKNAME即可。

在apache源码中D:\\httpd-2.4.9\\modules\\test目录下有mod\_optional\_hook\_export.c和mod\_optional\_hook\_import.c两个关于可选挂钩的Demo，可结合这两个进行分析。

说明：在第四步中实现了可选挂钩的函数并将其添加到了apache的内核可选挂钩哈希表中，在第五步中调用可选挂钩函数时会触发可选挂钩的实现函数，如果在一个模块内不需要调用可选挂钩函数，则第四、五两步可以省略不实现，比如apache自带的mod\_status模块仅仅有前三步骤，这样的模块只是定义了一个可选挂钩，当其他的模块若需要该可选挂钩的时候再来实现第四和五两步即可。

附：可选挂钩与普通(非可选)挂钩在使用上的区别：

对比上面一和三，我们可以发现，他们两者的区别主要在第二步添加上，对于用户自定义添加的普通挂钩，其所在模块必有一个挂钩结构体APR\_HOOK\_STRUCT来保存当前模块中的所有挂钩，挂钩注册的对象是当前模块的挂钩结构体(即：向当前模块的挂钩结构体内添加该挂钩的挂钩函数)；而可选挂钩由apache内核维护，具有全局可见性，因此在声明可选挂钩的模块内无需在挂钩结构体内在包含该挂钩了。

## **二．可选函数的使用** ##

**1、声明**

\#include <apr\_optional.h>

/\* Optional function \*/

APR\_DECLARE\_OPTIONAL\_FN(int, optional\_func, (request\_rec\*, int flags));

**2、实现**

static int optional\_func(request\_rec \*r, int flags)

ap\_rputs("<h4 style=\\"text-align: center\\"> Apache Optional Function </h4>\\n", r);

return 0;

**3、注册**

在模块register\_hooks函数内注册可选函数，将可选函数添加到apache内核维护的全局可选函数哈希表中。

/\* Optional Function 将可选函数注册到apache内核的全局可选函数哈希表中 \*/