nginx请求头数据读取流程

本文我们则主要讲解nginx是如何读取客户端发送来的请求头的数据，并且解析这些数据的。本质上来讲，请求行的数据和请求头的数据读取流程是基本一致的，因为其都面临着如何从间断的数据流中读取到数据，也面临着如何对数据进行处理的问题。

1. 请求头读取主流程

在介绍请求头的读取流程之前，我们首先展示一个http请求报文的示例：

POST /web/book/read HTTP/1.1
Host: localhost
Connection: keep-alive
Content-Length: 365
Accept: application/json, text/plain, */*

示例中的第一行数据就是请求行，而后面的几行都是请求头。每一个请求头都是以name: value的格式组装的，并且每一个请求头都占用一行。在上一篇介绍请求行读取流程的文章中，我们讲到，一旦请求行读取完成，nginx就会将当前读取事件的回调函数修改为
ngx_http_process_request_headers()方法，并且直接调用该方法尝试读取请求头数据。这个方法就是读取请求行数据的主流程，如下是该方法的源码：

/**
 * 解析客户端发送来的header数据
 */
static void ngx_http_process_request_headers(ngx_event_t *rev) {
  u_char *p;
  size_t len;
  ssize_t n;
  ngx_int_t rc, rv;
  ngx_table_elt_t *h;
  ngx_connection_t *c;
  ngx_http_header_t *hh;
  ngx_http_request_t *r;
  ngx_http_core_srv_conf_t *cscf;
  ngx_http_core_main_conf_t *cmcf;

  c = rev->data;
  r = c->data;

  if (rev->timedout) {
    ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
    c->timedout = 1;
    ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
    return;
  }

  cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
  rc = NGX_AGAIN;

  for (;;) {
    if (rc == NGX_AGAIN) {
      // 如果当前header缓冲区中没有剩余空间，则申请新的空间
      if (r->header_in->pos == r->header_in->end) {
        // 申请新的空间
        rv = ngx_http_alloc_large_header_buffer(r, 0);
        if (rv == NGX_ERROR) {
          ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
          return;
        }

        // 客户端发送的header太长，超出了large_client_header_buffers指定的最大大小
        if (rv == NGX_DECLINED) {
          p = r->header_name_start;
          r->lingering_close = 1;
          if (p == NULL) {
            ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent too large request");
            ngx_http_finalize_request(r, NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
            return;
          }

          len = r->header_in->end - p;
          if (len > NGX_MAX_ERROR_STR - 300) {
            len = NGX_MAX_ERROR_STR - 300;
          }

          ngx_http_finalize_request(r, NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
          return;
        }
      }

      // 尝试读取连接上客户端新发送来的数据
      n = ngx_http_read_request_header(r);
      if (n == NGX_AGAIN || n == NGX_ERROR) {
        return;
      }
    }

    cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
    // 这里主要是对读取到的数据进行转换
    rc = ngx_http_parse_header_line(r, r->header_in, cscf->underscores_in_headers);

    // NGX_OK表示成功解析得到了一个header数据
    if (rc == NGX_OK) {
      r->request_length += r->header_in->pos - r->header_name_start;
      // 过滤无效的header
      if (r->invalid_header && cscf->ignore_invalid_headers) {
        continue;
      }

      // 创建一个存储header的结构体
      h = ngx_list_push(&r->headers_in.headers);
      if (h == NULL) {
        ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
      }

      h->hash = r->header_hash;
      // 把header的name作为hash表的key
      h->key.len = r->header_name_end - r->header_name_start;
      h->key.data = r->header_name_start;
      h->key.data[h->key.len] = '\0';

      // 把header的value作为hash表的value
      h->value.len = r->header_end - r->header_start;
      h->value.data = r->header_start;
      h->value.data[h->value.len] = '\0';

      h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
      if (h->lowcase_key == NULL) {
        ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
      }

      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);
      }

      // headers_in_hash中存储了所有的header，这里是查找当前客户端传的header是否为有效的header
      hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash, h->lowcase_key, h->key.len);
      // 这里的handler是在ngx_http_headers_in中为每一个header定义的处理方法，经过各个header的
      // handler()方法处理后，客户端传来的header就都转换到r->headers_in结构体中的各个属性中了
      if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
        return;
      }

      continue;
    }

    // NGX_HTTP_PARSE_HEADER_DONE表示已经将所有的header都处理完成了
    if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
      r->request_length += r->header_in->pos - r->header_name_start;
      r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;
      // 检查客户端发送来的header数据的合法性
      rc = ngx_http_process_request_header(r);
      if (rc != NGX_OK) {
        return;
      }

      ngx_http_process_request(r);
      return;
    }

    // NGX_AGAIN表示读取到的header行数据不完全，还需要继续读取
    if (rc == NGX_AGAIN) {
      continue;
    }
    
    ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent invalid header line");
    ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
    return;
  }
}

这里请求头的读取主要分为如下几个步骤：

首先检查当前读取事件是否已经超时，如果超时了，则直接关闭当前连接；
判断是否r->header_in->pos == r->header_in->end成立，这个主要是检查当前读取缓冲区中是否有可以存储新读取的数据的内存空间，如果没有，则从内存池中新申请一块内存空间；
调用ngx_http_read_request_header()方法读取当前连接句柄上的数据，其返回值如果大于0，则表示读取到的数据长度，如果等于0，则表示客户端断开了连接，如果为NGX_ERROR，则表示读取发生了异常，如果为NGX_AGAIN，则此次没有读取到数据，需要继续读取新的数据。可以看到，这里首先判断返回值是否为NGX_AGAIN，是则直接返回，而没有做任何其他的处理，这主要是因为当前的读事件的回调函数还是ngx_http_process_request_headers()，当有新的读事件触发时，其还是会调用到ngx_http_read_request_header()以再次读取到数据。另一方面，在ngx_http_read_request_header()方法中，如果发现返回值为NGX_AGAIN，其会将当前读事件再次添加到事件队列中，并且为当前连接在epoll句柄上注册读事件；
调用ngx_http_parse_header_line()方法解析读取到的请求头数据，需要注意的是，每次调用该方法都只会解析得到一个请求头，不过经过无限for循环和不停的事件触发机制，最终所有的请求头数据都会读取到。
根据ngx_http_parse_header_line()方法的返回值，如果为NGX_OK，则将新读取到的header存储到r->headers_in.headers链表中；
如果ngx_http_parse_header_line()方法的返回值为NGX_HTTP_PARSE_HEADER_DONE，则表示读取所有的header都成功了，此时首先会调用ngx_http_process_request_header()方法检查读取到的header的合法性，然后调用ngx_http_process_request()方法以启动nginx中http模块的11个阶段，这个方法的实现原理我们将会在后面的文章进行讲解。

2. 请求头数据的读取

可以看到，对请求头的读取主要有两个方法：
ngx_http_read_request_header()和
ngx_http_parse_header_line()。这里的第二个方法比较长，但是其逻辑非常的简单，主要就是解析读取到的数据是否能组成一个完整的请求头（name: value的形式，并且占用一行），如果是，则返回NGX_OK，否则返回NGX_AGAIN以期待继续读取数据。对于这个方法，我们这里不进行讲解，读者可自行阅读源码，我们主要讲解
ngx_http_read_request_header()方法是如何读取客户端发送来的请求头数据的：

static ssize_t ngx_http_read_request_header(ngx_http_request_t *r) {
  ssize_t n;
  ngx_event_t *rev;
  ngx_connection_t *c;
  ngx_http_core_srv_conf_t *cscf;

  c = r->connection;
  rev = c->read;

  // 计算当前还有多少数据未处理
  n = r->header_in->last - r->header_in->pos;

  // 如果n大于0，说明还有读取到的数据未处理，则直接返回n
  if (n > 0) {
    return n;
  }

  // 走到这里，说明当前读取到的数据都已经处理完了，因而这里会进行判断，如果当前事件的ready参数为1，
  // 则表示当前连接的句柄上存储还未读取的数据，因而调用c->recv()方法读取数据，否则继续将当前事件添加到
  // 事件队列中，并且继续监听当前连接句柄的读事件
  if (rev->ready) {
    // 在连接文件描述符上读取数据
    n = c->recv(c, r->header_in->last, r->header_in->end - r->header_in->last);
  } else {
    n = NGX_AGAIN;
  }

  // 如果n为NGX_AGAIN，则将当前事件添加到事件监听器中，并且继续监听当前epoll句柄的读事件
  if (n == NGX_AGAIN) {
    if (!rev->timer_set) {
      cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
      ngx_add_timer(rev, cscf->client_header_timeout);
    }

    if (ngx_handle_read_event(rev, 0) != NGX_OK) {
      ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
      return NGX_ERROR;
    }

    return NGX_AGAIN;
  }

  // 如果n为0，说明客户端关闭了连接
  if (n == 0) {
    ngx_log_error(NGX_LOG_INFO, c->log, 0, "client prematurely closed connection");
  }

  // 如果客户端关闭了连接或者读取异常，则回收当前的request结构体
  if (n == 0 || n == NGX_ERROR) {
    c->error = 1;
    c->log->action = "reading client request headers";
    ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
    return NGX_ERROR;
  }

  // 更新当前读取到的数据指针
  r->header_in->last += n;
  return n;
}

这里请求头数据的读取主要分为如下几个步骤：

判断当前缓冲区中是否存在还未处理的数据，如果存在，则直接返回。存在还未读取的数据的原因主要是在前面读取请求行数据的过程中，可能会读取一部分或者全部的请求头数据，因而这里会做检查；
判断当前读事件是否已经准备就绪，如果已经就绪，则调用c->recv()方法读取当前连接句柄上的数据；
如果当前读事件还未就绪，则将当前的读事件再次添加到事件队列中，并且为当前连接在epoll句柄上注册读事件；
对第二步的返回值进行判断，如果为0，则表示客户端已经断开了连接，如果为NGX_ERROR，则表示读取数据异常了，这两种情况时都会关闭当前连接，并且向客户端返回400状态码。如果返回值NGX_AGAIN，则从事第三步中的步骤，以继续监听读事件。如果返回值大于0，则表示读取成功，而这个大于0的值就表示读取到的数据长度；
更新存储读取数据的缓冲区的指针数据。