/ # httpd -V
Server version: Apache/2.4.41 (Unix)       # 主体版本
Server built:   Jul 14 2021 21:07:58
Server's Module Magic Number: 20120211:88
Server loaded:  APR 1.7.0, APR-UTIL 1.6.1
Compiled using: APR 1.7.0, APR-UTIL 1.6.1  # APR和APU版本

/ # httpsd -l
  core.c
  mod_so.c
  http_core.c
  prefork.c  # 使用的mpm模块
  mod_ssl.c
  mod_reqtimeout.c

DST_DIR=/usr/myapache

## 安装依赖，如下...etc
## apt install libexpat-dev libpcre3-dev
# 编译expat
wget https://github.com/libexpat/libexpat/releases/download/R_2_2_10/expat-2.2.10.tar.gz
tar xf expat-2.2.10.tar.gz && cd expat-2.2.10/
./configure --host=x86_64-linux31-linux-gnu CFLAGS='-g' --prefix=$DST_DIR
make && make install

# 编译pcre
wget https://sourceforge.net/projects/pcre/files/pcre/8.44/pcre-8.44.tar.gz
tar xf pcre-8.44.tar.gz && cd pcre-8.44/
./configure --host=x86_64-linux31-linux-gnu CFLAGS='-g' --prefix=$DST_DIR
make && make install

# 编译apr
wget https://dlcdn.apache.org/apr/apr-1.7.0.tar.gz
tar xf apr-1.7.0.tar.gz && cd apr-1.7.0
./configure --host=x86_64-linux31-linux-gnu CFLAGS='-g' --prefix=$DST_DIR
make && make install

# 编译apr-util
wget https://dlcdn.apache.org/apr/apr-util-1.6.1.tar.gz
tar xf apr-util-1.6.1.tar.gz && cd apr-util-1.6.1
./configure --host=x86_64-linux31-linux-gnu CFLAGS='-g' --prefix=$DST_DIR --with-apr=$DST_DIR --with-expat=$DST_DIR
make && make install 

# 编译httpd，注由于上面的prefork是默认的所以此处未指定，否则需要指定对应的mpm模块
wget https://archive.apache.org/dist/httpd/httpd-2.4.41.tar.gz
tar xf httpd-2.4.41.tar.gz && cd httpd-2.4.41
./configure --host=x86_64-linux31-linux-gnu CFLAGS='-g' --with-apr=$DST_DIR --with-apr-util=$DST_DIR --prefix=$DST_DIR --with-pcre=$DST_DIR --enable-static-support
make && make install

# 选择需要的版本：https://archive.apache.org/dist/httpd/ ，如1.3.27
wget https://archive.apache.org/dist/httpd/apache_1.3.27.tar.gz
tar xf apache_1.3.27.tar.gz
cd apache_1.3.27/src
cp Configuration.tmpl Configuration
# 编辑Configuration，在CFLAGS下添加-g，其他按需修改
./Configure
make

static INLINE int ap_os_is_path_absolute(const char *file)
{
  return file[0] == '/';
}

# 下载对应版本的mod_ssl，在Apache1上需要通过打补丁的方式hook，因此版本需对应
wget http://www.modssl.org/source/OBSOLETE/mod_ssl-2.8.13-1.3.27.tar.gz
# 安装依赖，需注意openssl需要1.0以下，否则需要做很多修改
apt install libgdbm-compat-dev libssl-dev
# 打补丁
tar xf mod_ssl-2.8.13-1.3.27.tar.gz && cd mod_ssl-2.8.13-1.3.27/
./configure --with-apache=/root/apache_1.3.27
# 修改上面的那个Configuration，添加如下内容
SSL_BASE=SYSTEM
Rule SSL_COMPAT=yes
Rule SSL_SDBM=default
Rule SSL_EXPERIMENTAL=no
Rule SSL_CONSERVATIVE=no
Rule SSL_VENDOR=no
Rule EAPI=yes
AddModule modules/ssl/mod_ssl.o
# 重新生成Makefile
./Configure
# 修改module/ssl/Makefile
# 将LIB=libssl.$(LIBEXT)改为libssl.a
# 重新编译
make

void* apr_palloc(apr_pool_t *p, apr_size_t size);
char* apr_psprintf(apr_pool_t *p,const char *fmt, ...);
char* apr_pstrcat(apr_pool_t *p, ...);

typedef struct module_struct {
    int version;        /* API版本，用于指示与core的兼容性 */
    int minor_version;          /* API的小版本，仅用于表示一些feature，在初始化时会忽略它 */
    int module_index;       /* 模块索引，在加载后会被初始化，用于索引配置 */

    const char *name;  /* 模块的文件名，在分析时通过该名称可猜测模块作用，特别是静态链接时 */
    void *dynamic_load_handle;  /* 模块的句柄，如dlopen的返回值 */

    struct module_struct *next;  /* 链接到下一个模块，初始化后有效，所有模块会以链表形式组合在一起 */

    unsigned long magic;        /* 模块的魔数，通过它可以将模块分为不同类，并在之后按分类调用 */

    void (*init) (server_rec *, pool *);  /* 初始化代码，在配置解析后被执行 */
    void *(*create_dir_config) (pool *p, char *dir);  /* 创建每目录配置 */
    void *(*merge_dir_config) (pool *p, void *base_conf, void *new_conf); /* 合并每目录配置 */
    void *(*create_server_config) (pool *p, server_rec *s);  /* 创建每服务配置 */
    void *(*merge_server_config) (pool *p, void *base_conf, void *new_conf);  /* 合并每服务配置 */

    const command_rec *cmds;  /* 指令列表，里面指示了支持的指令，指令说明，解析函数 */
    const handler_rec *handlers;  /* 生成器列表，里面指示了声明的生成器名称与对应的执行函数 */

    int (*translate_handler) (request_rec *);  /* 转换URI到文件名 */
    int (*ap_check_user_id) (request_rec *);  /* 从http请求里获取用户ID并检查 */
    int (*auth_checker) (request_rec *);  /* 检查授权 */
    int (*access_checker) (request_rec *); /* 通过主机地址等进行一些基本检查 */
    int (*type_checker) (request_rec *);  /* 探测请求的MINE并设置content-type等，也可能会设置handler，如mod_mime就是在此处实现SetHandler的 */
    int (*fixer_upper) (request_rec *);  /* 请求被处理前的最后步骤，想做的其他事都可以在这里完成 */
    int (*logger) (request_rec *);  /* 记录事务 */
    int (*header_parser) (request_rec *);  /* 解析请求头 */

    void (*child_init) (server_rec *, pool *); /* 在新进程(不含轻量级进程)创建后执行 */
    void (*child_exit) (server_rec *, pool *); 
    int (*post_read_request) (request_rec *);  /* 在普通请求和内部重定向请求(不包含子请求)被读取后执行 */
#ifdef APACHE_SSL
/* 剩下的部分是原始结构没有的，若提供的钩子不能满足需求就可以扩展该结构新增钩子与回调点 */
    void (*setup_connection)(conn_rec *);  /* apache-ssl的钩子，用于在连接建立时封装 */
    void (*add_common_vars)(request_rec *);  
#endif
} module;

struct module_struct {
    int version;
    int minor_version;
    int module_index;

    const char *name;
    void *dynamic_load_handle;

    struct module_struct *next;
    unsigned long magic;

    void (*rewrite_args) (process_rec *process);  /* 这是个特殊的hook，用于mpm重写命令行参数，它会在很早前被调用，若以单独放这里 */

    void *(*create_dir_config) (apr_pool_t *p, char *dir);
    void *(*merge_dir_config) (apr_pool_t *p, void *base_conf, void *new_conf);
    void *(*create_server_config) (apr_pool_t *p, server_rec *s);
    void *(*merge_server_config) (apr_pool_t *p, void *base_conf,
                                  void *new_conf);

    const command_rec *cmds;
    void (*register_hooks) (apr_pool_t *p);  // 主要的钩子和过滤器都由它注册
    int flags;
};

// 在module里注册了三个钩子函数
module MODULE_VAR_EXPORT proxy_module =
{
    STANDARD_MODULE_STUFF,      /* 填充前几位的宏，标准模块直接调用它，非标准模块，如对该结构进行了扩充需要修改magic时可直接填充 */
    .....
    proxy_trans,                /* translate_handler */
    NULL,                       /* check_user_id */
    NULL,                       /* check auth */
    NULL,                       /* check access */
    NULL,                       /* type_checker */
    proxy_fixup,                /* pre-run fixups */
    NULL,                       /* logger */
    NULL,                       /* header parser */
    NULL,                       /* child_init */
    NULL,                       /* child_exit */
    proxy_detect                /* post read-request */
};

// 在core的process_request_internal里会调用ap_translate_name/ap_run_fixups等钩子函数
static void process_request_internal(request_rec *r)
{
    ...
    if ((access_status = ap_translate_name(r))) {
        decl_die(access_status, "translate", r);
        return;
    }
    ...
    if ((access_status = ap_run_fixups(r)) != 0) {
        ap_die(access_status, r);
        return;
    }
    ...
}

API_EXPORT(int) ap_run_fixups(request_rec *r)
{
    return run_method(r, offsets_into_method_ptrs.fixer_upper, 1);
}

static int run_method(request_rec *r, int offset, int run_all)
{
    int i;

    for (i = offset; method_ptrs[i]; ++i) {
    handler_func mod_handler = method_ptrs[i];

    if (mod_handler) {
        int result;

        result = (*mod_handler) (r);

        if (result != DECLINED && (!run_all || result != OK))
        return result;
    }
    }

    return run_all ? OK : DECLINED;
}

AP_DECLARE_MODULE(proxy) =
{
    STANDARD20_MODULE_STUFF,
    ...
    register_hooks
};

static void register_hooks(apr_pool_t *p)
{

    static const char * const aszSucc[] = { "mod_rewrite.c", NULL};
    static const char *const aszPred[] = { "mpm_winnt.c", "mod_proxy_balancer.c",
                                           "mod_proxy_hcheck.c", NULL};
    /* handler */
    ap_hook_handler(proxy_handler, NULL, NULL, APR_HOOK_FIRST);
    /* filename-to-URI translation */
    ap_hook_translate_name(proxy_trans, aszSucc, NULL, APR_HOOK_FIRST);
    /* walk <Proxy > entries and suppress default TRACE behavior */
    ap_hook_map_to_storage(proxy_map_location, NULL,NULL, APR_HOOK_FIRST);
    /* fixups */
    ap_hook_fixups(proxy_fixup, NULL, aszSucc, APR_HOOK_FIRST);
    ...
}

ap_hook_<hookname>  // 用于注册(挂钩)勾子
ap_run_<hookname>       // 用于调用勾子

#define     APR_HOOK_REALLY_FIRST   (-10)
#define     APR_HOOK_FIRST   0
#define     APR_HOOK_MIDDLE   10
#define     APR_HOOK_LAST   20
#define     APR_HOOK_REALLY_LAST   30

void ap_hook_fixups(ap_HOOK_fixups_t *pf_0, const char *const *aszPre, const char *const *aszSucc, int nOrder)
{
  ap_LINK_fixups_t_0 *pHook;

  if ( !hooks_3.link_fixups )
  {
    hooks_3.link_fixups = (apr_array_header_t_0 *)apr_array_make(apr_hook_global_pool, 1LL, 40LL);
    apr_hook_sort_register();
  }
  pHook = (ap_LINK_fixups_t_0 *)apr_array_push(hooks_3.link_fixups);
  pHook->pFunc = pf_0;
  pHook->aszPredecessors = aszPre;
  pHook->aszSuccessors = aszSucc;
  pHook->nOrder = nOrder;
  pHook->szName = (const char *)apr_hook_debug_current;
  if ( apr_hook_debug_enabled )
    apr_hook_debug_show();
}

int __cdecl ap_run_fixups(request_rec_0 *r)
{
  char *pHook; // [rsp+10h] [rbp-10h]
  int rv; // [rsp+18h] [rbp-8h]
  int n; // [rsp+1Ch] [rbp-4h]

  rv = 0;
  if ( !hooks_3.link_fixups )
    return rv;
  pHook = hooks_3.link_fixups->elts;
  for ( n = 0; n < hooks_3.link_fixups->nelts; ++n )
  {
    rv = (*(__int64 (__fastcall **)(request_rec_0 *))&pHook[40 * n])(r);
    if ( rv )
    {
      if ( rv != -1 )
        break;
    }
    rv = 0;
  }
  return rv;
}

#define OK 0                    /** 该模块已经成功处理 */
#define DECLINED -1             /** 不能处理，由其他模块继续处理 */
#define DONE -2                                 /** 该hook已经做完了，不必再继续执行其他hook */

// 无论如何执行所有hook
#define AP_IMPLEMENT_HOOK_VOID(name,args_decl,args_use) ...
// 执行所有hook，若过程中出现错误则停止(ret!=ok&&ret!=decline)
#define AP_IMPLEMENT_HOOK_RUN_ALL(ret,name,args_decl,args_use,ok,decline)  ...
// 执行到第一个成功或发生错误时停止(ret!=decline)
#define AP_IMPLEMENT_HOOK_RUN_FIRST(ret,name,args_decl,args_use,decline)  ...

AP_DECLARE(apr_status_t) ap_rgetline_core(char **s, apr_size_t n,
                                          apr_size_t *read, request_rec *r,
                                          int flags, apr_bucket_brigade *bb)
{
    do {
        // 让下一个过滤器填充bb
        apr_brigade_cleanup(bb);
        rv = ap_get_brigade(r->proto_input_filters, bb, AP_MODE_GETLINE,
                            APR_BLOCK_READ, 0);

        // 遍历brigade里的每一个bucket并处理
        for (e = APR_BRIGADE_FIRST(bb); e != APR_BRIGADE_SENTINEL(bb); e = APR_BUCKET_NEXT(e))
        {
            if (APR_BUCKET_IS_EOS(e)) { saw_eos = 1; break; }   // 若是EOS则不再继续了
            rv = apr_bucket_read(e, &str, &len, APR_BLOCK_READ);  // 从bucket读数据
            // 处理数据
            ...
        }
    } while (!saw_eol);
}

AP_DECLARE(apr_status_t) ap_get_brigade(...)
{ 
  // 从下一个过滤器中获取数据
  return next->frec->filter_func.in_func(next, bb, mode, block, readbytes); 
}

// 注册输入/输出过滤器
AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name, ap_in_filter_func filter_func, ap_init_filter_func filter_init, ap_filter_type ftype);
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name, ap_out_filter_func filter_func, ap_init_filter_func filter_init, ap_filter_type ftype);
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter_protocol(const char *name, ap_out_filter_func filter_func, ap_init_filter_func filter_init, ap_filter_type ftype, unsigned int proto_flags);

// 依据名称添加输入/输出过滤器
AP_DECLARE(ap_filter_t *) ap_add_input_filter(const char *name, void *ctx, request_rec *r, conn_rec *c);
AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx, request_rec *r, conn_rec *c);

// 直接添加输入/输出过滤器
AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f, void *ctx, request_rec *r, conn_rec *c);
AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f, void *ctx, request_rec *r, conn_rec *c);

AP_CORE_DECLARE_NONSTD(apr_status_t) ap_content_length_filter(ap_filter_t *f, apr_bucket_brigade *b)
{
    // 获取ctx，一般过滤器都会有这步，因为一个请求/连接中可能会多次调用输入/数次，此时可通过ctx记录一些状态
    if (!f->ctx) {
        // 表明是第一次调用
        f->ctx = ctx = apr_palloc(r->pool, sizeof(*ctx));
        ctx->data_sent = 0;
        ctx->tmpbb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
    }
        // 开始处理数据
    e = APR_BRIGADE_FIRST(b);
    while (e != APR_BRIGADE_SENTINEL(b)) {
       // 各种处理操作，这里面可能也会调用ap_pass_brigade将部分数据传给下个过滤器，也可能先直接返回
    }
        // 将数据传给下一个过滤器
    return ap_pass_brigade(f->next, b);
}

core_server_config *conf = r->server->module_config[core_module.module_index];
core_dir_config *conf = r->per_dir_config[core_module.module_index];

struct request_rec {
    apr_pool_t *pool; /** 请求的资源池，该请求里所有资源申请都应通过它完成，请求结束资源自动释放 */
    conn_rec *connection; /** 请求的连接 */
    server_rec *server;  /** 请求对应的服务 */

    request_rec *prev;  /** 当该请求是内部重定向请求时，指向上一个请求 */
    request_rec *main;  /** 当这是子请求时，指向主请求 */

    char *the_request;  /** 请求的第一行 */

    int proxyreq;  /* 代理标志，如mod_proxy会在post_read里识别是否是代理请求，并设置该标志 */
    int header_only;  /** 这是个HEAD请求，只返回头部不返回body */
    int proto_num;  /** Protocol version number of protocol; 1.1 = 1001 */
    char *protocol;  /** Protocol string, as given to us, or HTTP/0.9 */

    const char *hostname;      /** 由Host头或URI设置 */
    const char *status_line;  /** Status line, if set by script */
    int status;  /** Status line */

    int method_number;  /** M_GET, M_POST, etc. */
    const char *method; /** Request method (eg. GET, HEAD, POST, etc.) */

    apr_int64_t allowed;  /* 允许的请求，位向量 */ 
    ap_method_list_t *allowed_methods;  /** List of allowed methods */

    apr_table_t *headers_in;    /** 请求头 */
    apr_table_t *headers_out;  /** 响应头 */
    apr_table_t *err_headers_out;      /** 响应头，但是在出错或内部重定向时也可用 */

    apr_table_t *subprocess_env;   /** 子过程使用的环境变量 */
    apr_table_t *notes;  /** 一个表，叫笔记，各模块间可通过它传递数据 */

    const char *content_type;
    const char *handler;        /* handler名称，最终会由该名称对应的handler生成响应 */

    char *user;  /** 若有认证，则存储用户名和认证类型 */
    char *ap_auth_type;

    char *unparsed_uri;  /** 未执行任何解析的URI */
    char *uri;  /** URI的路径部分，若没有路径则为"/" */
    char *filename;  /** 这个响应对应的本地文件的文件名 */
    char *canonical_filename;  /* 真正在文件系统上的文件名，比如短文件名可访问，但实际文件名是长的 */ 
    char *path_info;  /** 从请求里提取的 PATH_INFO */
    char *args;  /** 从请求里提取的 QUERY_ARGS */

    int eos_sent;  /** A flag to determine if the eos bucket has been sent yet */

    struct ap_conf_vector_t *per_dir_config;  /** Options set in config files, etc. */
    struct ap_conf_vector_t *request_config;  /** Notes on *this* request */

    struct ap_filter_t *output_filters;   /** 该请求使用的输入输出过滤器 */
    struct ap_filter_t *input_filters;

    struct ap_filter_t *proto_output_filters;   /** 协议级的输入输出过滤器 */
    struct ap_filter_t *proto_input_filters; 

    apr_uri_t parsed_uri;  /** 解析后的URI信息 */
    apr_finfo_t finfo;  /** 若请求的是文件且存在，此处为文件信息 */
};

int REALMAIN(int argc, char *argv[])
{
    // 第一部分，各种初始化，解析配置，加载模块，监听端口等
    common_init();  // 一些公共的初始化，如信号处理，资源池初始化
    ...
    ap_cpystrn(ap_server_root, HTTPD_ROOT, sizeof(ap_server_root));  // 设置配置路径
    ap_cpystrn(ap_server_confname, SERVER_CONFIG_FILE, sizeof(ap_server_confname));

    ap_setup_prelinked_modules();  // 初始化静态链接的模块，将其加入运行时的链表

    while ((c = getopt(argc, argv, "D:C:c:xXd:Ff:vVlLR:StTh")) != -1) {
        switch (c) {  // 处理命令行参数
        case 'c':
            new = (char **)ap_push_array(ap_server_post_read_config);
            *new = ap_pstrdup(pcommands, optarg);
            break;
          ...
            }
    }

    ap_suexec_enabled = init_suexec();
    server_conf = ap_read_config(pconf, ptrans, ap_server_confname);

    if (ap_standalone) {}else {
        ap_set_version();
        ap_init_modules(pconf, server_conf);
        ap_open_logs(server_conf, plog);
        ap_init_modules(pconf, server_conf); // 此处模块被初始化了两次，因为解析配置后需要再次初始化信息
        set_group_privs();

    if (!geteuid() && setuid(ap_user_id) == -1) {}

    server_conf->port = ntohs(((struct sockaddr_in *) &sa_server)->sin_port);
    // 第二部分，建立连接并处理数据
    conn = new_connection(ptrans, server_conf, cio,
                      (struct sockaddr_in *) &sa_client,
                      (struct sockaddr_in *) &sa_server, -1);  // 封装连接

#ifdef APACHE_SSL
      ap_setup_connection(conn);  // 若是ssl需要对连接做额外的操作
#endif

    while ((r = ap_read_request(conn)) != NULL) {  // 从连接里获取一个请求，⚠️这里只读了请求头
            ap_process_request(r);  // 处理请求
        if (!conn->keepalive || conn->aborted)break;  // 若是keepalive型连接，循环读取并处理
            }
    }
}

API_EXPORT(void) ap_process_request(request_rec *r)
{
    ...
    process_request_internal(r);
}

static void process_request_internal(request_rec *r)
{
    if (r->proxyreq == NOT_PROXY && r->parsed_uri.path) {
            access_status = ap_unescape_url(r->parsed_uri.path);  // url解码操作，如果是代理请求或请求结构的parsed_uri.path没有赋值则不处理
    }

    ap_getparents(r->uri);     /* 该函数用于正规化path,即去掉../和./ */

    if ((access_status = location_walk(r))) { }  // 设置Location层级的配置
    if ((access_status = ap_translate_name(r))) {  }  // 对URI进行转换，如alias/rewrite可在此处进行
        ...

    if ((access_status = directory_walk(r))) {  }  //  设置Directory层级的配置 
    if ((access_status = file_walk(r))) {  }  // 设置File层级的配置
    if ((access_status = location_walk(r))) {  }  // 再次调用，因为前面的转换可能会修改uri
    if ((access_status = ap_header_parse(r))) { }  // 解析头部，并可设置环境变量等

    switch (ap_satisfies(r)) {
    case SATISFY_ALL:
    case SATISFY_NOSPEC:
        if ((access_status = ap_check_access(r)) != 0) { }  // 如检查IP/访问频率等
        if (ap_some_auth_required(r)) {
            // 检查用户是否存在，密码是否正确等
            if (((access_status = ap_check_user_id(r)) != 0) || !ap_auth_type(r)) {  }
            // 检查用户是否有权限访问
            if (((access_status = ap_check_auth(r)) != 0) || !ap_auth_type(r)) { }
        }
        break;
    }

    if (! (r->proxyreq != NOT_PROXY  && r->parsed_uri.scheme != NULL && strcmp(r->parsed_uri.scheme, "http") == 0) ) {
    if ((access_status = ap_find_types(r)) != 0) { }  // 执行type_checker钩子，设置mime
    }

    if ((access_status = ap_run_fixups(r)) != 0) {  }  // 执行fixups钩子，最后其他的设置都可以扔这里哦
    if ((access_status = ap_invoke_handler(r)) != 0) {  } // 调用handler

    ap_finalize_request_protocol(r);
}

static int ap_process_http_connection(conn_rec *c)
{
    // http的process_connection会根据mpm类型调用异步/同步处理函数
    if (async_mpm && !c->clogging_input_filters) { }
    else {
        return ap_process_http_sync_connection(c);  // 这里选择同步来分析
    }
}

static int ap_process_http_sync_connection(conn_rec *c)
{
    while ((r = ap_read_request(c)) != NULL) {  // 从连接里读取一个请求
        if (r->status == HTTP_OK) { ap_process_request(r);  } // 处理单个请求      
        if (c->keepalive != AP_CONN_KEEPALIVE || c->aborted) break;  // 若不是keepalive型的连接，则退出，否则循环读取连接
    }
}

AP_DECLARE(void) ap_process_request(request_rec *r) -> void ap_process_async_request(request_rec *r)
{
    access_status = ap_run_quick_handler(r, 0);  /* Not a look-up request */
    if (access_status == DECLINED) {
        access_status = ap_process_request_internal(r);  /* 处理request */
        if (access_status == OK) {
            access_status = ap_invoke_handler(r);  /* 调用handler */
        }
    }
}

request_rec *ap_read_request(conn_rec *conn)
{
    // 创建并初始化request，重点关注如下
    apr_pool_create(&p, conn->pool);  // 从连接的资源池创建子池作为请求的资源池
    r = apr_pcalloc(p, sizeof(request_rec));
    r->pool            = p;
    r->connection      = conn;
    r->server          = conn->base_server; // 初始为默认服务

    r->request_config  = ap_create_request_config(r->pool);

    r->proto_output_filters = conn->output_filters; // 这里的过滤器初始于连接，且协议与普通一致
    r->output_filters  = r->proto_output_filters;
    r->proto_input_filters = conn->input_filters;
    r->input_filters   = r->proto_input_filters;
    ap_run_create_request(r);  // 运行create_request钩子，它可对request自定义与初始化
    r->per_dir_config  = r->server->lookup_defaults;  // 每目录配置默认值

        // 创建bragade用于传递给输入过滤器获取数据
    tmp_bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);

    ap_run_pre_read_request(r, conn);  // 运行pre_read_request钩子，在读请求前做些事情
    if (!read_request_line(r, tmp_bb)) { }  // 真正读请求
    if (!r->assbackwards) { ap_get_mime_headers_core(r, tmp_bb);  }
    ap_update_vhost_from_headers(r);  // 通过读到的请求头更新vhost

    ap_add_input_filter_handle(ap_http_input_filter_handle, NULL, r, r->connection);
    if (access_status != HTTP_OK || (access_status = ap_run_post_read_request(r))) {  }

}

AP_CORE_DECLARE(int) ap_invoke_handler(request_rec *r)
{
        ...
    ap_run_insert_filter(r);
    // 执行输入输出过滤器的初始化，一般都不必实现初始化函数 
    result = invoke_filter_init(r, r->input_filters);  
    result = invoke_filter_init(r, r->output_filters);

    // 若没有设置handler，则根据content-type设置，content-type之前已经设置过了
    if (!r->handler) {
        if (r->content_type) {
            handler = r->content_type;
                        ...
        }
        else {
            handler = AP_DEFAULT_HANDLER_NAME;
        }
        r->handler = handler;
    }

    result = ap_run_handler(r);  // 调用handler hook
  ...
}

netstat -pantu|grep -i listen # 获取监听的进程
ps aux |grep <httpd-pid>            # 获取httpd的启动参数
httpd -V                                            # 获取它的编译信息：版本，apr，模块，root目录，默认配置文件路径
grep -vE '(^\s*#)|(^$)' <httpd.conf>            # 查看它的所有配置，关注用了哪些模块，有哪些路由等
grep -vE '(^\s*#)|(^$)' <extra/*>                   # 通常该目录下会有很多子配置...