深入理解Nginx：模块开发与架构解析

// 注意每一项都需要在create_loc_conf的实现中，给出UNSET含义的初值
static ngx_command_t ngx_http_mytest_commands[] = {
// …
  {
    // 当出现test_flag on/off时，进行解析，解析结果写入my_flag字段
    ngx_string("test_flag"),
    NGX_HTTP_LOC_CONF| NGX_CONF_FLAG,
    ngx_conf_set_flag_slot,
    NGX_HTTP_LOC_CONF_OFFSET,
    offsetof(ngx_http_mytest_conf_t, my_flag),
    NULL
  },
  {
    // 当出现test_str xxxx时解析，写入my_str字段
    ngx_string("test_str"),
    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF| NGX_CONF_TAKE1,
    ngx_conf_set_str_slot,
    NGX_HTTP_LOC_CONF_OFFSET,
    offsetof(ngx_http_mytest_conf_t, my_str),
    NULL
  },
  ngx_null_command
};

/*
struct {
  ngx_http_upstream_conf_t upstream;
  ...
} ngx_http_mytest_conf_t;
*/
offsetof(ngx_http_mytest_conf_t, upstream.connect_timeout)

// 假定此次要处理的配置项，是由两个参数构成
typedef struct {
  ngx_str_t my_config_str;
  ngx_int_t my_config_num;
} ngx_http_mytest_conf_t;

static char* ngx_conf_set_myconfig(ngx_conf_t* cf, ngx_command_t cmd, void* conf)
{
  /* 注意，参数conf就是HTTP框架传给用户的在
  ngx_http_mytest_create_loc_conf回调方法中分配的结构体
  ngx_http_mytest_conf_t */
  ngx_http_mytest_conf_t mycf = conf;
  /* cf->args是1个ngx_array_t队列，它的成员都是
  ngx_str_t结构。我们用value指向ngx_array_t的
  elts内容，其中value[1]就是第1个参数，同理，
  value[2]是第2个参数 */
  ngx_str_t value = cf->args->elts;
  // ngx_array_t的nelts表示参数的个数
  if (cf->args->nelts > 1)
  {
    // 直接赋值即可，ngx_str_t结构只是指针的传递
    mycf->my_config_str = value[1];
  }
  if (cf->args->nelts > 2)
  {
    // 将字符串形式的第2个参数转为整型
    mycf->my_config_num = ngx_atoi(value[2].data, value[2].len);
    /* 如果字符串转化整型失败，将报“invalid number”错误，
    Nginx启动失败 */
    if (mycf->my_config_num == NGX_ERROR) {
      return "invalid number";
    }
  }
  // 返回成功
  return NGX_CONF_OK;
}

static char* ngx_http_mytest_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
  ngx_http_mytest_conf_t *prev = (ngx_http_mytest_conf_t *)parent;
  ngx_http_mytest_conf_t *conf = (ngx_http_mytest_conf_t *)child;
  // 如果父级优先级更高，用父覆盖子级
  ngx_conf_merge_str_value(conf->my_str,
    prev->my_str, "defaultstr");
  return NGX_CONF_OK;
}

typedef struct {
  /* 指针数组，数组中的每个元素指向所有HTTP模块
  create_main_conf方法产生的结构体 */
  void *main_conf;
  /* 指针数组，数组中的每个元素指向所有
  HTTP模块create_srv_conf方法产生的结构体 */
  void *srv_conf;
  /* 指针数组，数组中的每个元素指向所有
  HTTP模块create_loc_conf方法产生的结构体 */
  void *loc_conf;
} ngx_http_conf_ctx_t;

// 此处的r就是ngx_http_request_t，module是各模块定义的ngx_module_t类型变量
// 从这里也可以看出，任何对请求上下文的读写操作，都是从请求处开始的
#define ngx_http_get_module_ctx(r, module) (r)->ctx[module.ctx_index]
#define ngx_http_set_ctx(r, c, module) r->ctx[module.ctx_index] = c;

// 模块自定义handler
static ngx_int_t ngx_http_mytest_handler(ngx_http_request_t *r)
{
  // 首先调用ngx_http_get_module_ctx宏来获取上下文结构体
  ngx_http_mytest_ctx_t* myctx = ngx_http_get_module_ctx(r,ngx_http_mytest_module);
  // 如果之前没有设置过上下文，那么应当返回NULL
  if (myctx == NULL)
  {
    /* 必须在当前请求的内存池r->pool中分配上下文结构体，这样请求结束时结构体占用的内存才会释放 */
    myctx = ngx_palloc(r->pool, sizeof(ngx_http_mytest_ctx_t));
    if (myctx == NULL)
    {
      return NGX_ERROR;
    }
    // 将刚分配的结构体设置到当前请求的上下文中
    ngx_http_set_ctx(r,myctx,ngx_http_mytest_module);
  }
  // 之后可以任意使用myctx这个上下文结构体
  // ...
}

typedef struct ngx_http_upstream_s ngx_http_upstream_t; struct ngx_http_upstream_s {
  // …
  /* request_bufs决定发送什么样的请求给上游服务器，在实现
  create_request方法时需要设置它*/
  ngx_chain_t *request_bufs;
  // upstream访问时的所有限制性参数，包括连接、发送和接收超时时间等
  ngx_http_upstream_conf_t *conf;
  // 通过resolved可以直接指定上游服务器地址，地址个数、地址数组
  ngx_http_upstream_resolved_t *resolved;
  /* buffer成员存储接收自上游服务器发来的响应内容，由于它会被复用，所以具有下列多种意义：
    a)在使用process_header方法解析上游响应的包头时，buffer中将会保存完整的响应包头；
    b)当下面的buffering成员为1，而且此时upstream是向下游转发上游的包体时，buffer没有意义；
    c)当buffering标志位为0时，buffer缓冲区会被用于反复地接收上游的包体，进而向下游转发；
    d)当upstream并不用于转发上游包体时，buffer会被用于反复接收上游的包体，HTTP模块实现的
      input_filter方法需要关注它 */
  ngx_buf_t buffer;
  // 构造发往上游服务器的请求内容
  ngx_int_t (*create_request)(ngx_http_request_t *r);
  /* 收到上游服务器的响应后就会回调process_header方法。
  如果process_header返回NGX_AGAIN，那么是在告诉
  upstream还没有收到完整的响应包头，此时，对于本次
  upstream请求来说，再次接收到上游服务器发来的TCP流时，
  还会调用process_header方法处理，直到process_header函数返回非
  NGX_AGAIN值这一阶段才会停止 */
  ngx_int_t (*process_header)(ngx_http_request_t *r);
  // 销毁upstream请求时调用
  void (*finalize_request)(ngx_http_request_t *r, ngx_int_t rc); 
  
  // 5个可选的回调方法
  // 自定义接收包体前的初始化阶段（内存等），不定义的话，upstream将会使用默认实现
  ngx_int_t (*input_filter_init)(void *data);
  // 自定义接收包体，不定义也有默认实现
  ngx_int_t (*input_filter)(void *data, ssize_t bytes);
  // upstream时，如果发现已向上游发送请求，但连接断开，会尝试重连，并调用该函数
  ngx_int_t (*reinit_request)(ngx_http_request_t *r);
  void (*abort_request)(ngx_http_request_t *r);
  ngx_int_t (*rewrite_redirect)(ngx_http_request_t *r, ngx_table_elt_t *h, size_t prefix);
  // SSL协议访问上游服务器
  unsigned ssl:1;
  /* 在向客户端转发上游服务器的包体时才有用。当buffering为1时，
  表示使用多个缓冲区以及磁盘文件来转发上游的响应包体。
  当Nginx与上游间的网速远大于Nginx与下游客户端间的网速时，
  让Nginx开辟更多的内存甚至使用磁盘文件来缓存上游的响应包体，
  这是有意义的，它可以减轻上游服务器的并发压力。
  当buffering为0时，表示只使用上面的这一个buffer缓冲区来向下游转发响应包体 */
  unsigned buffering:1;
  // …
};

// 本例子针对新浪财经股票板块，注意2024年3月6日，此时需要为请求添加Referer才能不被服务器拒绝，配置如下
/*
location /list {
  # 子请求依然可以从配置中寻找对应的location，这是一个递归的过程
  proxy_pass http://hq.sinajs.cn;
  # 为了防止被新浪拒绝
  proxy_set_header Referer http://finance.sina.com.cn;
  # 不进行压缩
  proxy_set_header Accept-Encoding "";
}

location /query {
  # 用于启动自定义模块
  mysubrequest;
}

*/

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>
static ngx_int_t ngx_http_mysubrequest_handler(ngx_http_request_t *r);
 
static char* ngx_http_mysubrequest(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

static void mysubrequest_post_handler(ngx_http_request_t *r);
 
static ngx_command_t ngx_http_mysubrequest_commands[] = {
		{
				ngx_string("mysubrequest"),
				NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LMT_CONF | NGX_CONF_NOARGS,
				ngx_http_mysubrequest,
				NGX_HTTP_LOC_CONF_OFFSET,
				0,
				NULL
		},
		ngx_null_command
};
 
 
/**
 * 模块上下文
 */
static ngx_http_module_t ngx_http_mysubrequest_module_ctx = { NULL, NULL, NULL, NULL,
		NULL, NULL, NULL, NULL };
 
/**
 * 模块的定义
 */
ngx_module_t ngx_http_mysubrequest_module = {
    NGX_MODULE_V1,
    &ngx_http_mysubrequest_module_ctx,
    ngx_http_mysubrequest_commands,
    NGX_HTTP_MODULE,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NGX_MODULE_V1_PADDING
};

static char* ngx_http_mysubrequest(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
	ngx_http_core_loc_conf_t *clcf;
 
	clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
	clcf->handler = ngx_http_mysubrequest_handler;
 
	return NGX_CONF_OK;
}

typedef struct {
    ngx_str_t stock[6];
} ngx_http_mysubrequest_ctx_t;

// 子请求的回调
static ngx_int_t mysubrequest_subrequest_post_handler(ngx_http_request_t *r, void *data, ngx_int_t rc) {
  // 当前请求r是子请求，它的parent成员指向父请求
  ngx_http_request_t *pr = r->parent;
  /* 注意，由于上下文是保存在父请求中的，所以要由pr取上下文。其实有更简单的方法，即参数
  data就是上下文，初始化subrequest时就对其进行设置。这里仅为了说明如何获取到父请求的上下文 */
  ngx_http_mysubrequest_ctx_t* myctx = ngx_http_get_module_ctx(pr,ngx_http_mysubrequest_module);
  pr->headers_out.status = r->headers_out.status;
  /* NGX_HTTP_OK（也就是200），则意味着访问新浪服务器成功，接着将开始解析HTTP包体 */
  if (r->headers_out.status == NGX_HTTP_OK) {
    int flag = 0;
    /* 在不转发响应时，buffer中会保存上游服务器的响应。特别是在使用反向代理模块访问上游服务器时，如果它使用
    upstream机制时没有重定义input_filter方法，upstream机制默认的input_filter方法会试图把所有的上游响应全部保存到buffer缓冲区中 */
    ngx_buf_t* pRecvBuf = &r->upstream->buffer;
    /* 以下开始解析上游服务器的响应，并将解析出的值赋到上下文结构体myctx->stock数组中 */
    // 这里的解析是因为我们的访问是使用了对新浪财经板块的引用，已知他的返回结构，做了对应的解析
    for (;pRecvBuf->pos != pRecvBuf->last; pRecvBuf->pos++) {
      if (*pRecvBuf->pos == ',' || *pRecvBuf->pos == '\"') {
        if (flag > 0)
        {
          myctx->stock[flag-1].len = pRecvBuf->pos-myctx->stock[flag-1].data;
        }
        flag++;
        myctx->stock[flag-1].data = pRecvBuf->pos+1;
      }
      if (flag > 6)
        break;
    }
  }
  // 设置接下来父请求的回调方法，这一步很重要
  pr->write_event_handler = mysubrequest_post_handler;
  return NGX_OK;
}

// 父请求的回调
static void mysubrequest_post_handler(ngx_http_request_t *r) {
  // 如果没有返回200，则直接把错误码发回用户
  if (r->headers_out.status != NGX_HTTP_OK) {
    ngx_http_finalize_request(r, r->headers_out.status); return;
  }
  // 当前请求是父请求，直接取其上下文
  ngx_http_mysubrequest_ctx_t* myctx = ngx_http_get_module_ctx(r,ngx_http_mysubrequest_module);
  /* 定义发给用户的HTTP包体内容，格式为：stock[…],Today current price: …, volumn: … */
  ngx_str_t output_format = ngx_string("stock[%V],Today current price: %V, volumn: %V");
  // 计算待发送包体的长度
  int bodylen = output_format.len + myctx->stock[0].len +myctx->stock[1].len+myctx->stock[4].len-6;
  r->headers_out.content_length_n = bodylen;
  //
  ngx_buf_t* b = ngx_create_temp_buf(r->pool, bodylen);
  ngx_snprintf(b->pos, bodylen, (char*)output_format.data, &myctx->stock[0],&myctx->stock[1],&myctx->stock[4]);
  b->last = b->pos + bodylen;
  b->last_buf = 1;
  ngx_chain_t out;
  out.buf = b;
  out.next = NULL;
  // 设置Content-Type，注意，在汉字编码方面，新浪服务器使用了GBK
  static ngx_str_t type = ngx_string("text/plain; charset=GBK");
  r->headers_out.content_type = type;
  r->headers_out.status = NGX_HTTP_OK;
  r->connection->buffered |= NGX_HTTP_WRITE_BUFFERED;
  ngx_int_t ret = ngx_http_send_header(r);
  ret = ngx_http_output_filter(r, &out);
  /* ngx_http_finalize_request结束请求，因为这时HTTP框架不会再帮忙调用它 */
  ngx_http_finalize_request(r, ret);
}

static ngx_int_t ngx_http_mysubrequest_handler(ngx_http_request_t *r) {
  // 创建HTTP上下文
  ngx_http_mysubrequest_ctx_t* myctx = ngx_http_get_module_ctx(r,ngx_http_mysubrequest_module);
  if (myctx == NULL)
  {
    myctx = ngx_palloc(r->pool, sizeof(ngx_http_mysubrequest_ctx_t));
    if (myctx == NULL)
    {
      return NGX_ERROR;
    }
    // 将上下文设置到原始请求r中
    ngx_http_set_ctx(r,myctx,ngx_http_mysubrequest_module);
  }
  // ngx_http_post_subrequest_t结构体会决定子请求的回调方法，参见
  ngx_http_post_subrequest_t *psr = ngx_palloc(r->pool, sizeof(ngx_http_post_subrequest_t));
  if (psr == NULL) {
    return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }
  // 设置子请求回调方法为mysubrequest_subrequest_post_handler
  psr->handler = mysubrequest_subrequest_post_handler;

  /* 将data设为myctx上下文，这样回调mysubrequest_subrequest_post_handler时传入的data参数就是myctx*/
  psr->data = myctx;
  /* 子请求的URI前缀是/list，这是因为访问新浪服务器的请求必须是类似/list=s_sh000001的URI，
  这与在nginx.conf中配置的子请求location的URI是一致的 */
  ngx_str_t sub_prefix = ngx_string("/list=");
  ngx_str_t sub_location;
  sub_location.len = sub_prefix.len + r->args.len;
  sub_location.data = ngx_palloc(r->pool, sub_location.len);
  ngx_snprintf(sub_location.data, sub_location.len, "%V%V",&sub_prefix,&r->args);
  // 作为subrequest，将多个子请求合并为最终响应结果返回给父请求的发起方
  ngx_log_error(NGX_LOG_DEBUG, r->connection->log, 0, "subrequest url request content====> %V", &sub_location);
  // sr
  ngx_http_request_t *sr;
  /* 调用ngx_http_subrequest创建子请求，它只会返回NGX_OK或者NGX_ERROR。返回NGX_OK时，sr已经是合法的子请求。
  注意，这里的NGX_HTTP_SUBREQUEST_IN_MEMORY参数将告诉upstream模块把上游服务器的响应全部保存在子请求的
  sr->upstream->buffer内存缓冲区中 */
  ngx_int_t rc = ngx_http_subrequest(r, &sub_location, NULL, &sr, psr, NGX_HTTP_SUBREQUEST_IN_MEMORY);
  if (rc != NGX_OK) {
    return NGX_ERROR;
  }
  // 必须返回NGX_DONE，原因同upstream
  return NGX_DONE;
}

// 对头部过滤
typedef ngx_int_t (*ngx_http_output_header_filter_pt)(ngx_http_request_t r);
// 对包体过滤
typedef ngx_int_t (ngx_http_output_body_filter_pt)(ngx_http_request_t r, ngx_chain_t chain);

// 过滤器链表头部
extern ngx_http_output_header_filter_pt ngx_http_top_header_filter;
// 过滤器链表包体
extern ngx_http_output_body_filter_pt ngx_http_top_body_filter;

// 在自定义编码实际编写时，ngx_http_next_header_filter和ngx_http_next_body_filter都必须是static静态变量

static ngx_int_t ngx_http_myfilter_init(ngx_conf_t *cf) {
    // 插入到头部处理方法链表的首部
    ngx_http_next_header_filter = ngx_http_top_header_filter;
    ngx_http_top_header_filter = ngx_http_myfilter_header_filter;
    //
    ngx_http_next_body_filter = ngx_http_top_body_filter;
    ngx_http_top_body_filter = ngx_http_myfilter_body_filter;
    return NGX_OK;
}

/*
其他各种模块
static ngx_int_t ngx_xxx_filter_init(ngx_conf_t *cf) {  ... }
*/

// 查看代码可知write_filter是最初的链表头，write_filter也是最早进行初始化的
static ngx_int_t ngx_http_write_filter_init(ngx_conf_t *cf)
{
    ngx_http_top_body_filter = ngx_http_write_filter;
    return NGX_OK;
}

// 实际使用中
static ngx_int_t ngx_http_myfilter_header_filter(ngx_http_request_t *r) {
  // ...
  // 调用下一个
  return ngx_http_next_header_filter(r);
}

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>
#include <ngx_log.h>

typedef struct {
    ngx_flag_t enable;
} ngx_http_myfilter_conf_t;

static void* ngx_http_myfilter_create_conf(ngx_conf_t *cf) {
    ngx_http_myfilter_conf_t *mycf;
    // 创建存储配置项的结构体
    mycf = (ngx_http_myfilter_conf_t *)ngx_pcalloc(cf->pool, sizeof(ngx_http_myfilter_conf_t));
    if (mycf == NULL) {
        return NULL;
    }
    // ngx_flat_t类型的变量。如果使用预设函数ngx_conf_set_flag_slot解析配置项参数，那么必须初始化为NGX_CONF_UNSET
    mycf->enable= NGX_CONF_UNSET;
    return mycf;
}

static char* ngx_http_myfilter_merge_conf(ngx_conf_t *cf, void *parent, void *child) {
    ngx_http_myfilter_conf_t *prev = (ngx_http_myfilter_conf_t *)parent;
    ngx_http_myfilter_conf_t *conf = (ngx_http_myfilter_conf_t *)child; 
    //ngx_flat_t类型的配置项enable
    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    return NGX_CONF_OK;
}

typedef struct {
    ngx_int_t add_prefix;
} ngx_http_myfilter_ctx_t;

static ngx_command_t ngx_http_myfilter_commands[] = {
    {
        ngx_string("add_prefix"),
        NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LMT_CONF|NGX_CONF_FLAG,
        ngx_conf_set_flag_slot,
        NGX_HTTP_LOC_CONF_OFFSET,
        offsetof(ngx_http_myfilter_conf_t, enable),
        NULL
    },
    ngx_null_command
};

// 前置声明
static ngx_int_t ngx_http_myfilter_init(ngx_conf_t *cf);

static ngx_http_module_t ngx_http_myfilter_module_ctx = {
    NULL, /* preconfiguration方法 */
    ngx_http_myfilter_init, /* postconfiguration方法 */
    NULL, /* create_main_conf方法 */
    NULL, /* init_main_conf方法 */
    NULL, /* create_srv_conf方法 */
    NULL, /* merge_srv_conf方法 */
    ngx_http_myfilter_create_conf,/* create_loc_conf方法 */
    ngx_http_myfilter_merge_conf /* merge_loc_conf方法 */
};

ngx_module_t ngx_http_myfilter_module = {
    NGX_MODULE_V1,
    &ngx_http_myfilter_module_ctx, /* module context */
    ngx_http_myfilter_commands, /* module directives */
    NGX_HTTP_MODULE, /* module type */
    NULL, /* init master */
    NULL, /* init module */
    NULL, /* init process */
    NULL, /* init thread */
    NULL, /* exit thread */
    NULL, /* exit process */
    NULL, /* exit master */
    NGX_MODULE_V1_PADDING
};

static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static ngx_http_output_body_filter_pt ngx_http_next_body_filter;

// 前置声明
static ngx_int_t ngx_http_myfilter_header_filter(ngx_http_request_t *r);
static ngx_int_t ngx_http_myfilter_body_filter(ngx_http_request_t *r, ngx_chain_t *in);

static ngx_int_t ngx_http_myfilter_init(ngx_conf_t *cf) {
    // 插入到头部处理方法链表的首部
    ngx_http_next_header_filter = ngx_http_top_header_filter;
    ngx_http_top_header_filter = ngx_http_myfilter_header_filter;
    //
    ngx_http_next_body_filter = ngx_http_top_body_filter;
    ngx_http_top_body_filter = ngx_http_myfilter_body_filter;
    return NGX_OK;
}

static ngx_str_t filter_prefix = ngx_string("[my filter prefix]");

static ngx_int_t ngx_http_myfilter_header_filter(ngx_http_request_t *r) {
    ngx_http_myfilter_ctx_t *ctx;
    ngx_http_myfilter_conf_t *conf;
    /* 如果不是返回成功，那么这时是不需要理会是否加前缀的，直接交由下一个过滤模块处理响应码非200的情况 */
    if (r->headers_out.status != NGX_HTTP_OK) {
        return ngx_http_next_header_filter(r);
    }
    // 获取HTTP上下文
    ctx = ngx_http_get_module_ctx(r, ngx_http_myfilter_module);
    if (ctx) {
        /* 该请求的上下文已经存在，这说明ngx_http_myfilter_header_filter已经被调用过1次，直接交由下一个过滤模块处理 */
        return ngx_http_next_header_filter(r);
    }
    // 获取存储配置项的ngx_http_myfilter_conf_t结构体
    conf = ngx_http_get_module_loc_conf(r, ngx_http_myfilter_module);
    /* 如果enable成员为0，也就是配置文件中没有配置add_prefix配置项，或者add_prefix配置项的参数值是off，那么这时直接交由下一个过滤模块处理 */
    if (conf->enable == 0) {
        return ngx_http_next_header_filter(r);
    }
    // 构造HTTP上下文结构体ngx_http_myfilter_ctx_t
    ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_myfilter_ctx_t));
    if (ctx == NULL) {
        return NGX_ERROR;
    }
    // add_prefix为0表示不加前缀
    ctx->add_prefix = 0;
    // 将构造的上下文设置到当前请求中
    ngx_http_set_ctx(r, ctx, ngx_http_myfilter_module);
    // myfilter过滤模块只处理Content-Type是“text/plain”类型的HTTP响应
    if (r->headers_out.content_type.len >= sizeof("text/plain") - 1
        && ngx_strncasecmp(r->headers_out.content_type.data, (u_char *) "text/plain",sizeof("text/plain") - 1) == 0) {
        // 设置为1表示需要在HTTP包体前加入前缀
        ctx->add_prefix = 1;
        /* 当处理模块已经在Content-Length中写入了HTTP包体的长度时，由于我们加入了前缀字符串
        ，所以需要把这个字符串的长度也加入到Content-Length中*/
        if (r->headers_out.content_length_n > 0)
            r->headers_out.content_length_n += filter_prefix.len;
    }
    // 交由下一个过滤模块继续处理
    return ngx_http_next_header_filter(r);
}

static ngx_int_t ngx_http_myfilter_body_filter(ngx_http_request_t *r, ngx_chain_t *in) {
    ngx_http_myfilter_ctx_t *ctx;
    ctx = ngx_http_get_module_ctx(r, ngx_http_myfilter_module);
    /* 如果获取不到上下文，或者上下文结构体中的add_prefix为0或者2时，都不会添加前缀，这时直接交给下一个HTTP过滤模块处理 */
    if (ctx == NULL || ctx->add_prefix != 1) {
        return ngx_http_next_body_filter(r, in);
    }
    /* 将add_prefix设置为2，这样即使ngx_http_myfilter_body_filter再次回调时，也不会重复添加前缀 */
    ctx->add_prefix = 2;
    // 从请求的内存池中分配内存，用于存储字符串前缀
    ngx_buf_t* b = ngx_create_temp_buf(r->pool, filter_prefix.len);
    // 将ngx_buf_t中的指针正确地指向filter_prefix字符串
    b->start = b->pos = filter_prefix.data; b->last = b->pos + filter_prefix.len;
    /* 从请求的内存池中生成ngx_chain_t链表，将刚分配的ngx_buf_t设置到buf成员中，并将它添加到原先待发送的HTTP包体前面 */
    ngx_chain_t *cl = ngx_alloc_chain_link(r->pool);
    cl->buf = b;
    cl->next = in;
    // 调用下一个模块的HTTP包体处理方法，注意，这时传入的是新生成的cl链表
    return ngx_http_next_body_filter(r, cl);
}

typedef enum {
  // 在接收到完整的HTTP头部后处理的HTTP阶段
  NGX_HTTP_POST_READ_PHASE = 0,
  /* 在还没有查询到URI匹配的location前，
  这时rewrite重写URL也作为一个独立的HTTP阶段 */
  NGX_HTTP_SERVER_REWRITE_PHASE,

  /* 根据URI寻找匹配的location，
  这个阶段通常由ngx_http_core_module模块实现，
  不建议其他HTTP模块重新定义这一阶段的行为 */
  NGX_HTTP_FIND_CONFIG_PHASE,

  /* 在NGX_HTTP_FIND_CONFIG_PHASE阶段之后重写URL,
  与NGX_HTTP_SERVER_REWRITE_PHASE阶段显然是不同的，
  因为这两者会导致查找到不同的location块（location是与URI进行匹配的） */
  NGX_HTTP_REWRITE_PHASE,

  /* 这一阶段是用于在rewrite重写URL后重新跳到
  NGX_HTTP_FIND_CONFIG_PHASE阶段，找到与新的
  URI匹配的location。所以，这一阶段是无法由第三方
  HTTP模块处理的，而仅由ngx_http_core_module模块使用 */
  NGX_HTTP_POST_REWRITE_PHASE,

  /* 处理NGX_HTTP_ACCESS_PHASE阶段前，
  HTTP模块可以介入的处理阶段  */
  NGX_HTTP_PREACCESS_PHASE,

  /* 这个阶段用于让HTTP模块判断是否允许这个请求访问
  Nginx服务器 */
  NGX_HTTP_ACCESS_PHASE,

  /*当NGX_HTTP_ACCESS_PHASE阶段中HTTP模块的
  handler处理方法返回不允许访问的错误码时（实际是
  NGX_HTTP_FORBIDDEN或者NGX_HTTP_UNAUTHORIZED），
  这个阶段将负责构造拒绝服务的用户响应。
  所以，这个阶段实际上用于给NGX_HTTP_ACCESS_PHASE阶段收尾 */
  NGX_HTTP_POST_ACCESS_PHASE,
  
  /* 这个阶段完全是为了try_files配置项而设立的。
  当HTTP请求访问静态文件资源时，
  try_files配置项可以使这个请求顺序地访问多个静态文件资源，
  如果某一次访问失败，则继续访问try_files中指定的下一个静态资源。
  另外，这个功能完全是在NGX_HTTP_TRY_FILES_PHASE阶段中实现的 */
  NGX_HTTP_TRY_FILES_PHASE,

  // 用于处理HTTP请求内容的阶段，这是大部分HTTP模块最喜欢介入的阶段
  NGX_HTTP_CONTENT_PHASE,

  /* 处理完请求后记录日志的阶段。例如，
  ngx_http_log_module模块就在这个阶段中加入了一个
  handler处理方法，使得每个HTTP请求处理完毕后会记录access_log日志 */
  NGX_HTTP_LOG_PHASE
} ngx_http_phases;

typedef ngx_int_t (*ngx_http_handler_pt)(ngx_http_request_t *r);

typedef struct ngx_http_request_s ngx_http_request_t;
struct ngx_http_request_s {
  ngx_uint_t method;
  ngx_uint_t http_version;
  ngx_str_t request_line;
  ngx_str_t uri;
  ngx_str_t args;
  ngx_str_t exten;
  ngx_str_t unparsed_uri;
  ngx_str_t method_name;
  ngx_str_t http_protocol;
  u_char *uri_start;
  u_char *uri_end;
  u_char *uri_ext;
  u_char *args_start;
  u_char *request_start;
  u_char *request_end;
  u_char *method_end;
  u_char *schema_start;
  u_char *schema_end;
  // 未经解析的头部
  ngx_buf_t *header_in;
  // 解析后的头部
  ngx_http_headers_in_t headers_in;
  // 请求响应的头部
  ngx_http_headers_out_t headers_out; 
  // 在请求处理过程中使用的内存池对象
  ngx_pool_t *pool;
  // 支持range断点续传
  unsigned allow_ranges:1;
  // 指向所有参与模块所使用的请求上下文的数组
  void **ctx;
  // upstream成员
  ngx_http_upstream_t *upstream;
  // 子请求postpone
  ngx_http_postpone_request_t *postponed;

  // ... 其他内容
};

// HTTP请求的头部
typedef struct {
  /* 所有解析过的HTTP头部都在headers链表中，
  每一个元素都是ngx_table_elt_t成员，这里是所有的头部字段，
  其中有一些标准定义的，会在结构体的后续字段中直接给出，
  对于不常见的/自定义的字段，需要自行遍历 */
  ngx_list_t headers; 

  /* 以下每个ngx_table_elt_t成员都是RFC2616规范中定义的HTTP头部，
  它们实际都指向headers链表中的相应成员。
  注意，当它们为NULL空指针时，表示没有解析到相应的HTTP头部 */
  ngx_table_elt_t *host; ngx_table_elt_t *connection; ngx_table_elt_t *if_modified_since;
  ngx_table_elt_t *if_unmodified_since; ngx_table_elt_t *user_agent; ngx_table_elt_t *referer;
  ngx_table_elt_t *content_length; ngx_table_elt_t *content_type; ngx_table_elt_t *range;
  ngx_table_elt_t *if_range; ngx_table_elt_t *transfer_encoding; ngx_table_elt_t *expect; 
#if (NGX_HTTP_GZIP)
  ngx_table_elt_t *accept_encoding;
  ngx_table_elt_t *via;
#endif
  ngx_table_elt_t *authorization; ngx_table_elt_t *keep_alive; 
#if (NGX_HTTP_PROXY || NGX_HTTP_REALIP || NGX_HTTP_GEO)
  ngx_table_elt_t *x_forwarded_for;
#endif
#if (NGX_HTTP_REALIP)
  ngx_table_elt_t *x_real_ip;
#endif
#if (NGX_HTTP_HEADERS)
  ngx_table_elt_t *accept; ngx_table_elt_t *accept_language;
#endif
#if (NGX_HTTP_DAV)
  ngx_table_elt_t *depth; ngx_table_elt_t *destination;
  ngx_table_elt_t *overwrite; ngx_table_elt_t *date;
#endif
  /* user和passwd是只有ngx_http_auth_basic_module才会用到的成员，这里可以忽略 */
  ngx_str_t user; ngx_str_t passwd; 
  /* cookies是以ngx_array_t数组存储的 */
  ngx_array_t cookies;
  // server名称
  ngx_str_t server;
  // 根据ngx_table_elt_t *content_length计算出的HTTP包体大小
  off_t content_length_n;
  time_t keep_alive_n; 
  /* HTTP连接类型，它的取值范围是0、
  NGX_http_CONNECTION_CLOSE或者
  NGX_HTTP_CONNECTION_KEEP_ALIVE */
  unsigned connection_type:2;
  /* 以下7个标志位是HTTP框架根据浏览器传来的useragent头部，
  它们可用来判断浏览器的类型，值为1时表示是相应的浏览器发来的请求，
  值为0时则相反 */
  unsigned msie:1;
  unsigned msie6:1;
  unsigned opera:1;
  unsigned gecko:1;
  unsigned chrome:1;
  unsigned safari:1;
  unsigned konqueror:1;
} ngx_http_headers_in_t;

// HTTP请求响应的头部
typedef struct {
  // 待发送的HTTP头部链表，与headers_in中的headers成员类似
  // 和headers_in中的一样，可以用ngx_list_push向其中添加自定义头部
  ngx_list_t headers;

  /* 响应中的状态值，如200表示成功。
  这里可以使用各个宏，如NGX_HTTP_OK */
  ngx_uint_t status;
  
  // 响应的状态行，如“HTTP/1.1 201 CREATED”
  ngx_str_t status_line;
  
  /* 以下成员（包括ngx_table_elt_t）都是
  RFC1616规范中定义的HTTP头部，设置后，
  ngx_http_header_filter_module过滤模块可以把它们加到待发送的网络包中 */
  ngx_table_elt_t *server; ngx_table_elt_t *date; ngx_table_elt_t *content_length;
  ngx_table_elt_t *content_encoding; ngx_table_elt_t *location;
  ngx_table_elt_t *refresh; ngx_table_elt_t *last_modified;
  ngx_table_elt_t *content_range; ngx_table_elt_t *accept_ranges;
  ngx_table_elt_t *www_authenticate; ngx_table_elt_t *expires; ngx_table_elt_t *etag;
  ngx_str_t *override_charset; 
  
  /* ngx_http_set_content_type(r)方法帮助我们设置
  Content-Type头部，这个方法会根据URI中的文件扩展名并对应着
  mime.type来设置Content-Type值 */
  size_t content_type_len;
  ngx_str_t content_type;
  ngx_str_t charset;
  u_char *content_type_lowcase;
  ngx_uint_t content_type_hash;
  ngx_array_t cache_control;

  /* content_length_n后，
  不用再次到ngx_table_elt_t *content_ length中设置响应长度 */
  off_t content_length_n;
  time_t date_time;
  time_t last_modified_time;
} ngx_http_headers_out_t;

// 调用该函数，要求nginx开始异步接收包体，接收结束的回调为post_handler
ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r, ngx_http_client_body_handler_pt post_handler);
// 回调函数的类型定义为
typedef void (*ngx_http_client_body_handler_pt)(ngx_http_request_t *r);
// 在该函数内，可以使用request_body来获取到缓存的临时文件，路径/名称等信息
// r->request_body->temp_file->file.name

// 接收包体时的通用写法
ngx_int_t rc = ngx_http_read_client_request_body(r, ngx_http_mytest_body_handler); 
if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  return rc;
}
return NGX_DONE;
// 舍弃包体
ngx_int_t rc = ngx_http_discard_request_body(r);
if (rc != NGX_OK) {
  return rc;
}

// 将准备好的request发送出去
ngx_int_t ngx_http_send_header(ngx_http_request_t *r);

// 发送包体，在这一步，会自动调用ngx_http_finalize_request，结束这次请求
ngx_int_t ngx_http_output_filter(ngx_http_request_t r, ngx_chain_t in);

// 如果不发送包体，也需要调用，提示请求结束处理
void ngx_http_finalize_request(ngx_http_request_t *r, ngx_int_t rc)

// 申请一个128字节大小的内存缓冲区
ngx_buf_t *b = ngx_create_temp_buf(r->pool, 128);

// 对发送情况进行判断
ngx_int_t rc = ngx_http_send_header(r); 
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  return rc;
}
// 如果有包体需要发送，则执行后续，否则可以直接return NGX_DONE;
ngx_buf_t *b = ngx_create_temp_buf(r->pool, 128);
/
ngx_chain_t out;
out.buf = b;
out.next = NULL;
return ngx_http_output_filter(r, &out);

ngx_buf_t *b;
b = ngx_palloc(r->pool, sizeof(ngx_buf_t));
// 例如计划读取文件test.txt
u_char* filename = (u_char*)"/tmp/test.txt";
// 标记为文件类buf
b->in_file = 1;
// 对ngx_file_t进行申请和填写
b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
b->file->fd = ngx_open_file(filename, NGX_FILE_RDONLY|NGX_FILE_NONBLOCK, NGX_FILE_OPEN, 0);
b->file->log = r->connection->log;
b->file->name.data = filename;
b->file->name.len = strlen(filename);
if (b->file->fd <= 0)
{
  return NGX_HTTP_NOT_FOUND;
}
// 对HTTP响应信息的填写，需要先获取文件信息
if (ngx_file_info(filename, &b->file->info) == NGX_FILE_ERROR)
{
  return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->headers_out.content_length_n = b->file->info.st_size;
b->file_pos = 0;
b->file_last = b->file->info.st_size;
// 设置文件句柄清理
ngx_pool_cleanup_t* cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
  return NGX_ERROR;
}
// 文件固定用ngx_pool_cleanup_file
cln->handler = ngx_pool_cleanup_file;
// 文件的清理类型是ngx_pool_cleanup_file_t
ngx_pool_cleanup_file_t *clnf = cln->data;
clnf->fd = b->file->fd;
clnf->name = b->file->name.data;
clnf->log = r->pool->log;

// r为ngx_http_request_t*
r->allow_ranges=1;

// 提升易用性的宏
#define ngx_log_error(level, log, args...) \
  if ((log)->log_level >= level) ngx_log_error_core(level, log, args)
#define ngx_log_debug(level, log, args...) \
  if ((log)->log_level & level) \
    ngx_log_error_core(NGX_LOG_DEBUG, log, args)

// 对于不可变参数平台，Nginx提供的接口形如
// ngx_log_debug0、ngx_log_debug1 ... 代表无参数、1个参数等

// 日志函数原型：本次日志级别、log参数（配置级别、日志文件等）、错误码、C风格格式字符串(不完全相同，请查文档)
void ngx_log_error_core(ngx_uint_t level, ngx_log_t log, ngx_err_t err, const char fmt, ...);

// 用例
ngx_log_error(NGX_LOG_ALERT, r->connection->log,0,
  "test_flag=%d,test_str=%V,path=%*s,mycf addr=%p",
  mycf->my_flag,
  &mycf->my_str,
  mycf->my_path->name.len,
  mycf->my_path->name.data,
  mycf);

// ngx_queue.h，API是若干宏
struct ngx_queue_s {
    ngx_queue_t  *prev;
    ngx_queue_t  *next;
};

// 使用方式：在自定义结构体内，嵌入链表元素
typedef struct {
  u_char* str;
  int num;
  ngx_queue_t qEle;
} TestNode;

// 初始化
ngx_queue_t queueContainer;
ngx_queue_init(&queueContainer);

// 从ngx_queue_t* a，获取TestNode
TestNode *aNode = ngx_queue_data(a, TestNode, qEle);

// 加入链表
ngx_queue_insert_tail(&queueContainer, &(aNode->qEle));

// 遍历
ngx_queue_t* q;
for (q = ngx_queue_head(&queueContainer);q != ngx_queue_sentinel(&queueContainer);q = ngx_queue_next(q))
{
  TestNode* eleNode = ngx_queue_data(q, TestNode, qEle);
  // ...
}

// 排序
ngx_queue_sort(&queueContainer, compTestNode);

// 其中compTestNode是比较函数，形如
ngx_int_t compTestNode(const ngx_queue_t* a, const ngx_queue_t* b) {
  return ngx_queue_data(a, TestNode, qEle)->num > ngx_queue_data(b, TestNode, qEle)->num;
}

typedef struct ngx_array_s ngx_array_t;
struct ngx_array_s {
  // elts指向数组的首地址
  void *elts;
  // nelts是数组中已经使用的元素个数
  ngx_uint_t nelts;
  // 每个数组元素占用的内存大小
  size_t size;
  // 当前数组中能够容纳元素个数的总大小
  ngx_uint_t nalloc;
  // 内存池对象
  ngx_pool_t *pool;
};


typedef struct TestNode {
  u_char* str;
  int num;
}
// 一组使用样例，cf为ngx_conf_t*，这里主要是为了使用以下内存池对象
// 创建动态数组
ngx_array_t* dynamicArray = ngx_array_create(cf->pool, 1, sizeof(TestNode));
// 创建元素
TestNode* a = ngx_array_push(dynamicArray);
a->num = 1;

TestNode* b = ngx_array_push_n(dynamicArray, 3);
b->num = 3;
(b+1)->num = 4;
(b+2)->num = 5;

TestNode* nodeArray = dynamicArray->elts;
ngx_uint_t arraySeq = 0;
for (; arraySeq < dynamicArray->nelts; arraySeq++)
{
  a = nodeArray + arraySeq;
  // 处理
}
ngx_array_destroy(dynamicArray);

typedef ngx_uint_t ngx_rbtree_key_t;
typedef struct ngx_rbtree_node_s ngx_rbtree_node_t;
// 红黑树节点
struct ngx_rbtree_node_s {
  // 无符号整型的关键字
  ngx_rbtree_key_t key;
  // 左子节点
  ngx_rbtree_node_t *left;
  // 右子节点
  ngx_rbtree_node_t *right;
  // 父节点
  ngx_rbtree_node_t *parent;
  // 节点的颜色，0表示黑色，1表示红色
  u_char color;
  // 仅1个字节的节点数据。由于表示的空间太小，所以一般很少使用
  u_char data;
};

// 需要使用红黑树时，将元素嵌入自定义数据结构体
typedef struct {
/* 一般都将ngx_rbtree_node_t节点结构体放在自定义数据类型的第1位，以方便类型的强制转换 */
  ngx_rbtree_node_t node;
  ngx_uint_t num;
} TestRBTreeNode;

// 真正的树结构
typedef struct ngx_rbtree_s ngx_rbtree_t;
/*为解决不同节点含有相同关键字的元素冲突问题，红黑树设置了
ngx_rbtree_insert_pt指针，这样可灵活地添加冲突元素*/
typedef void (*ngx_rbtree_insert_pt) (ngx_rbtree_node_t root,ngx_rbtree_node_t node, ngx_rbtree_node_t *sentinel);
struct ngx_rbtree_s {
  // 指向树的根节点。注意，根节点也是数据元素
  ngx_rbtree_node_t *root;
  // 指向NIL哨兵节点
  ngx_rbtree_node_t *sentinel;
  // 表示红黑树添加元素的函数指针，它决定在添加新节点时的行为究竟是替换还是新增
  ngx_rbtree_insert_pt insert;
};

// 操作示例

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>
#include <ngx_log.h>
 
static ngx_int_t ngx_http_myupstream_handler(ngx_http_request_t *r);
 
static char* ngx_http_myupstream(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

static ngx_int_t myupstream_upstream_process_header(ngx_http_request_t *r);

static void* ngx_http_myupstream_create_loc_conf(ngx_conf_t *cf);
static char* ngx_http_myupstream_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) ;
 
 
static ngx_command_t ngx_http_myupstream_commands[] = {
	{
			ngx_string("myupstream"),
			NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LMT_CONF | NGX_CONF_NOARGS,
			ngx_http_myupstream,
			NGX_HTTP_LOC_CONF_OFFSET,
			0,
			NULL
	},
	ngx_null_command
};
 
 
/**
 * 模块上下文
 */
static ngx_http_module_t ngx_http_myupstream_module_ctx = { NULL, NULL, NULL, NULL,
		NULL, NULL, ngx_http_myupstream_create_loc_conf, ngx_http_myupstream_merge_loc_conf };
 
/**
 * 模块的定义
 */
ngx_module_t ngx_http_myupstream_module = {
		NGX_MODULE_V1,
		&ngx_http_myupstream_module_ctx,
		ngx_http_myupstream_commands,
		NGX_HTTP_MODULE,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NGX_MODULE_V1_PADDING
};
 
/**
 * 命令解析的回调函数
 * 该函数中，主要获取loc的配置，并且设置location中的回调函数handler
 */
static char* ngx_http_myupstream(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
	ngx_http_core_loc_conf_t *clcf;
 
	clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
	/* 设置回调函数。当请求/myupstream的时候，会调用此回调函数 */
	clcf->handler = ngx_http_myupstream_handler;
 
	return NGX_CONF_OK;
}

// 在自定义模块配置中，加入所需要的upstream参数
typedef struct {
  ngx_http_upstream_conf_t upstream;
} ngx_http_myupstream_conf_t;

// 模块create_loc_conf的实现
static void* ngx_http_myupstream_create_loc_conf(ngx_conf_t *cf) {
  ngx_http_myupstream_conf_t *mycf;
  mycf = (ngx_http_myupstream_conf_t *)ngx_pcalloc(cf->pool, sizeof(ngx_http_myupstream_conf_t));
  if (mycf == NULL) {
    return NULL;
  }
  /* 以下简单的硬编码ngx_http_upstream_conf_t结构中的各成员，
  如超时时间，都设为1分钟，这也是HTTP反向代理模块的默认值 */
  mycf->upstream.connect_timeout = 60000;
  mycf->upstream.send_timeout = 60000;
  mycf->upstream.read_timeout = 60000;
  mycf->upstream.store_access = 0600;
  /* buffering已经决定了将以固定大小的内存作为缓冲区来转发上游的响应包体，
  这块固定缓冲区的大小就是buffer_size。
  如果buffering为1，就会使用更多的内存缓存来不及发往下游的响应。
  例如，最多使用bufs.num个缓冲区且每个缓冲区大小为bufs.size。
  另外，还会使用临时文件，临时文件的最大长度为max_temp_file_size */
  mycf->upstream.buffering = 0;
  mycf->upstream.bufs.num = 8;
  mycf->upstream.bufs.size = ngx_pagesize;
  mycf->upstream.buffer_size = ngx_pagesize;
  mycf->upstream.busy_buffers_size = 2 * ngx_pagesize;
  mycf->upstream.temp_file_write_size = 2 * ngx_pagesize;
  mycf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  /* upstream hide_headers成员必须要初始化（upstream在解析完上游服务器返回的包头时，
  会调用ngx_http_upstream_process_headers方法按照hide_headers成员将本应转发给下游的一些HTTP头部隐藏），
  这里将它赋为NGX_CONF_UNSET_PTR ，这是为了在merge合并配置项方法中使用
  upstream模块提供的ngx_http_upstream_hide_headers_hash方法初始化hide_headers成员 */
  mycf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  mycf->upstream.pass_headers = NGX_CONF_UNSET_PTR;
  return mycf;
}

static ngx_str_t  ngx_http_proxy_hide_headers[] = {
  ngx_string("Date"),
  ngx_string("Server"),
  ngx_string("X-Pad"),
  ngx_string("X-Accel-Expires"),
  ngx_string("X-Accel-Redirect"),
  ngx_string("X-Accel-Limit-Rate"),
  ngx_string("X-Accel-Buffering"),
  ngx_string("X-Accel-Charset"),
  ngx_null_string
};

// merge_loc_conf
static char *ngx_http_myupstream_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
  ngx_http_myupstream_conf_t *prev = (ngx_http_myupstream_conf_t *)parent;
  ngx_http_myupstream_conf_t *conf = (ngx_http_myupstream_conf_t *)child;
  ngx_hash_init_t hash;
  hash.max_size = 100;
  hash.bucket_size = 1024;
  hash.name = "proxy_headers_hash";
  // ngx_http_upstream_hide_headers_hash具备合并功能，ngx_http_proxy_hide_headers是存储默认会隐藏的包头的数组
  if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream, &prev->upstream
    , ngx_http_proxy_hide_headers, &hash) != NGX_OK)
  {
    return NGX_CONF_ERROR;
  }
  return NGX_CONF_OK;
}

// 将status加入到ctx中
typedef struct {
  // ...
  ngx_http_status_t status;
  ngx_str_t backendServer;
} ngx_http_myupstream_ctx_t;

// 必须实现的回调之一：构造请求
static ngx_int_t myupstream_upstream_create_request(ngx_http_request_t *r) {
  /* 发往baidu上游服务器的请求很简单，就是模仿正常的搜索请求，
  以/searchq=…的URL来发起搜索请求 */
  static ngx_str_t backendQueryLine =
  // 注意这里的内容非常重要，如果有错误，会导致接到400系错误码
  ngx_string("GET /s?wd=%V HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: close\r\n\r\n"); 
  ngx_int_t queryLineLen = backendQueryLine.len + r->args.len - 2;
  /* epoll多次调度send才能发送完成，这时必须保证这段内存不会被释放；
  另一个好处是，在请求结束时，这段内存会被自动释放，降低内存泄漏的可能 */
  ngx_buf_t* b = ngx_create_temp_buf(r->pool, queryLineLen);
  if (b == NULL)
    return NGX_ERROR;
  // last要指向请求的末尾
  b->last = b->pos + queryLineLen;
  // 作用相当于snprintf
  ngx_snprintf(b->pos, queryLineLen ,
    (char*)backendQueryLine.data,&r->args);
  /* r->upstream->request_bufs是一个ngx_chain_t结构，它包含着要发送给上游服务器的请求 */
  r->upstream->request_bufs = ngx_alloc_chain_link(r->pool);
  if (r->upstream->request_bufs == NULL)
    return NGX_ERROR;
  // request_bufs在这里只包含1个ngx_buf_t缓冲区
  r->upstream->request_bufs->buf = b;
  r->upstream->request_bufs->next = NULL;
  r->upstream->request_sent = 0;
  r->upstream->header_sent = 0;
  // header_hash不可以为0
  r->header_hash = 1;
  return NGX_OK;
}

// 对返回数据的状态行进行解析
static ngx_int_t myupstream_process_status_line(ngx_http_request_t *r) {
  size_t len;
  ngx_int_t rc;
  ngx_http_upstream_t *u;
  // 上下文中才会保存多次解析HTTP响应行的状态，下面首先取出请求的上下文
  ngx_http_myupstream_ctx_t* ctx = ngx_http_get_module_ctx(r,ngx_http_myupstream_module);
  if (ctx == NULL) {
    return NGX_ERROR;
  }
  u = r->upstream;
  /* HTTP框架提供的ngx_http_parse_status_line方法可以解析HTTP响应行，
  它的输入就是收到的字符流和上下文中的ngx_http_status_t结构 */
  rc = ngx_http_parse_status_line(r, &u->buffer, &ctx->status);
  // 返回NGX_AGAIN时，表示还没有解析出完整的HTTP响应行，需要接收更多的字符流再进行解析
  if (rc == NGX_AGAIN) {
    return rc;
  }
  // 返回 NGX_ERROR时，表示没有接收到合法的HTTP响应行
  if (rc == NGX_ERROR) {
    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "upstream sent no valid HTTP/1.0 header");
    r->http_version = NGX_HTTP_VERSION_9;
    u->state->status = NGX_HTTP_OK;
    return NGX_OK;
  }
  /* 以下表示在解析到完整的HTTP响应行时，会做一些简单的赋值操作，
  将解析出的信息设置到r->upstream->headers_in结构体中。
  当upstream解析完所有的包头时，会把headers_in中的成员设置到将要向下游发送的
  r->headers_out结构体中，也就是说，现在用户向headers_in中设置的信息，
  最终都会发往下游客户端。为什么不直接设置r->headers_out而要多此一举呢？
  因为upstream希望能够按照ngx_http_upstream_conf_t配置结构体中的
  hide_headers等成员对发往下游的响应头部做统一处理 */
  if (u->state) {
    u->state->status = ctx->status.code;
  }
  u->headers_in.status_n = ctx->status.code;
  len = ctx->status.end - ctx->status.start;
  u->headers_in.status_line.len = len;
  u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  if (u->headers_in.status_line.data == NULL) {
    return NGX_ERROR;
  }
  ngx_memcpy(u->headers_in.status_line.data, ctx->status.start, len);
  /* 下一步将开始解析HTTP头部。设置process_header回调方法为
  myupstream_upstream_process_header，之后再收到的新字符流将由
  myupstream_upstream_process_header解析 */
  u->process_header = myupstream_upstream_process_header;
  /* 如果本次收到的字符流除了HTTP响应行外，还有多余的字符，
  那么将由myupstream_upstream_process_header方法解析 */
  return myupstream_upstream_process_header(r);
}

// 处理响应包头，process_header
static ngx_int_t myupstream_upstream_process_header(ngx_http_request_t *r) {
  ngx_int_t rc;
  ngx_table_elt_t *h;
  ngx_http_upstream_header_t *hh;
  ngx_http_upstream_main_conf_t *umcf;
  /* 这里将upstream模块配置项ngx_http_upstream_main_conf_t取出来，
  目的只有一个，就是对将要转发给下游客户端的HTTP响应头部进行统一处理。
  该结构体中存储了需要进行统一处理的HTTP头部名称和回调方法 */
  umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
  // 循环地解析所有的HTTP头部
  for ( ;; ) {
    /* HTTP框架提供了基础性的ngx_http_parse_header_line方法，它用于解析HTTP头部 */
    rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1);
    // 返回NGX_OK时，表示解析出一行HTTP头部
    if (rc == NGX_OK) {
      // 向headers_in.headers这个ngx_list_t链表中添加HTTP头部
      h = ngx_list_push(&r->upstream->headers_in.headers); if (h == NULL) {
        return NGX_ERROR;
      }
      // 下面开始构造刚刚添加到headers链表中的HTTP头部
      h->hash = r->header_hash;
      h->key.len = r->header_name_end - r->header_name_start;
      h->value.len = r->header_end - r->header_start;
      //HTTP头部的内存空间
      h->key.data = ngx_pnalloc(r->pool, h->key.len + 1 + h->value.len + 1 + h->key.len);
      if (h->key.data == NULL) {
        return NGX_ERROR;
      }
      h->value.data = h->key.data + h->key.len + 1;
      h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;
      ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
      h->key.data[h->key.len] = '\0';
      ngx_memcpy(h->value.data, r->header_start, h->value.len);
      h->value.data[h->value.len] = '\0';
      if (h->key.len == r->lowcase_index) {
        ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);
      } else {
        ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
      }
      // upstream模块会对一些HTTP头部做特殊处理
      hh = ngx_hash_find(&umcf->headers_in_hash, h->hash, h->lowcase_key, h->key.len);
      if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
        return NGX_ERROR;
      }
      continue;
    }
    /* 返回NGX_HTTP_PARSE_HEADER_DONE时，表示响应中所有的
    HTTP头部都解析完毕，接下来再接收到的都将是HTTP包体 */
    if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
    /* 如果之前解析HTTP头部时没有发现server和date头部，
    那么下面会根据HTTP协议规范添加这两个头部 */
    if (r->upstream->headers_in.server == NULL) {
      h = ngx_list_push(&r->upstream->headers_in.headers);
      if (h == NULL) {
        return NGX_ERROR;
      }
      h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(
        ngx_hash('s', 'e'), 'r'), 'v'), 'e'), 'r');
      ngx_str_set(&h->key, "Server");
      ngx_str_null(&h->value);
      h->lowcase_key = (u_char *) "server";
      }
      if (r->upstream->headers_in.date == NULL) {
        h = ngx_list_push(&r->upstream->headers_in.headers);
        if (h == NULL) {
          return NGX_ERROR;
        }
        h->hash = ngx_hash(ngx_hash(ngx_hash('d', 'a'), 't'), 'e');
        ngx_str_set(&h->key, "Date");
        ngx_str_null(&h->value);
        h->lowcase_key = (u_char *) "date"; 
      }
      return NGX_OK;
    }
    /*如果返回
    NGX_AGAIN，则表示状态机还没有解析到完整的
    HTTP头部，此时要求
    upstream模块继续接收新的字符流，然后交由
    process_header回调方法解析
    */
    if (rc == NGX_AGAIN) {
      return NGX_AGAIN;
    }
    // 其他返回值都是非法的
    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "upstream sent invalid header"); 
    return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  }
}

// 虽然finalize_request必须实现，但在本例中没有什么可做的
static void myupstream_upstream_finalize_request(ngx_http_request_t *r, ngx_int_t rc) {
  ngx_log_error(NGX_LOG_DEBUG, r->connection->log,0, "myupstream_upstream_finalize_request");
}

static ngx_int_t ngx_http_myupstream_handler(ngx_http_request_t *r) {
  // 首先建立HTTP上下文结构体ngx_http_myupstream_ctx_t
  ngx_http_myupstream_ctx_t* myctx = ngx_http_get_module_ctx(r,ngx_http_myupstream_module);
  if (myctx == NULL)
  {
    myctx = ngx_palloc(r->pool, sizeof(ngx_http_myupstream_ctx_t));
    if (myctx == NULL)
    {
      return NGX_ERROR;
    }
    // 将新建的上下文与请求关联起来
    ngx_http_set_ctx(r,myctx,ngx_http_myupstream_module);
  }
  /* 对每1个要使用upstream的请求，必须调用且只能调用1次ngx_http_upstream_create方法，
  它会初始化r->upstream成员 */
  if (ngx_http_upstream_create(r) != NGX_OK) {
    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,"ngx_http_upstream_create() failed");
    return NGX_ERROR;
  }
  // 得到配置结构体ngx_http_myupstream_conf_t
  ngx_http_myupstream_conf_t *mycf = 
    (ngx_http_myupstream_conf_t *) ngx_http_get_module_loc_conf(r, ngx_http_myupstream_module);
  ngx_http_upstream_t *u = r->upstream;
  // r->upstream->conf成员
  u->conf = &mycf->upstream;
  // 决定转发包体时使用的缓冲区
  u->buffering = mycf->upstream.buffering;
  // 以下代码开始初始化resolved结构体，用来保存上游服务器的地址
  u->resolved = 
    (ngx_http_upstream_resolved_t*) ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  if (u->resolved == NULL) {
    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0
      , "ngx_pcalloc resolved error. %s.", strerror(errno));
    return NGX_ERROR;
  }
  // 这里的上游服务器就是 www.baidu.com
  static struct sockaddr_in backendSockAddr; 
  struct hostent* pHost = gethostbyname((char*)"www.baidu.com");
  if (pHost == NULL)
  {
    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "gethostbyname fail. %s", strerror(errno));
    return NGX_ERROR;
  }
  // 访问上游服务器的80端口
  backendSockAddr.sin_family = AF_INET;
  backendSockAddr.sin_port = htons((in_port_t) 80);
  char* pDmsIP = inet_ntoa(*(struct in_addr*) (pHost->h_addr_list[0]));
  backendSockAddr.sin_addr.s_addr = inet_addr(pDmsIP);
  myctx->backendServer.data = (u_char*)pDmsIP;
  myctx->backendServer.len = strlen(pDmsIP);
  // resolved成员中
  u->resolved->sockaddr = (struct sockaddr *)&backendSockAddr;
  u->resolved->socklen = sizeof(struct sockaddr_in);
  u->resolved->naddrs = 1;
  // 少数和书上不同的位置，这里如果不设置port、host，会直接报错
  u->resolved->port = htons((in_port_t) 80);
  ngx_str_set(&u->resolved->host,"www.baidu.com");
  
  // 设置3个必须实现的回调方法，也就是5.3.3节~5.3.5节中实现的3个方法
  u->create_request = myupstream_upstream_create_request;
  u->process_header = myupstream_process_status_line;
  u->finalize_request = myupstream_upstream_finalize_request;
  // count成员加1，参见5.1.5节
  r->main->count++;
  // 启动upstream
  ngx_http_upstream_init(r);
  // 必须返回NGX_DONE
  return NGX_DONE;
}