本文我們則主要講解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的值就表示讀取到的數據長度；

• 更新存儲讀取數據的緩沖區的指針數據。