Detailed explanation of nginx request header data reading process

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

/**
 * Parse the header data sent by the client*/
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) {
   // If there is no remaining space in the current header buffer, apply for new space if (r->header_in->pos == r->header_in->end) {
    // Apply for new space rv = ngx_http_alloc_large_header_buffer(r, 0);
    if (rv == NGX_ERROR) {
     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
     return;
    }

    // The header sent by the client is too long and exceeds the maximum size specified by 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;
    }
   }

   // Try to read the newly sent data from the connected client 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);
  // Here we mainly convert the read data rc = ngx_http_parse_header_line(r, r->header_in, cscf->underscores_in_headers);

  // NGX_OK indicates successful parsing and obtaining a header data if (rc == NGX_OK) {
   r->request_length += r->header_in->pos - r->header_name_start;
   // Filter invalid headers
   if (r->invalid_header && cscf->ignore_invalid_headers) {
    continue;
   }

   // Create a structure to store headers 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;
   // Use the header name as the key of the hash table
   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';

   // Use the header value as the hash table 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 stores all headers. Here we check whether the header sent by the current client is a valid header.
   hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash, h->lowcase_key, h->key.len);
   // The handler here is the processing method defined for each header in ngx_http_headers_in. After being processed by the // handler() method of each header, the header sent by the client is converted to the various attributes in the r->headers_in structure if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
    return;
   }

   continue;
  }

  // NGX_HTTP_PARSE_HEADER_DONE means that all headers have been processed 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;
   // Check the legitimacy of the header data sent by the client rc = ngx_http_process_request_header(r);
   if (rc != NGX_OK) {
    return;
   }

   ngx_http_process_request(r);
   return;
  }

  // NGX_AGAIN indicates that the read header row data is incomplete and needs to be read further 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;
 }
}

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;

 // Calculate how much data is not processed yet n = r->header_in->last - r->header_in->pos;

 // If n is greater than 0, it means that there is still unprocessed data, then return n directly
 if (n > 0) {
  return n;
 }

 // Going here means that the currently read data has been processed, so a judgment will be made here. If the ready parameter of the current event is 1,
 // This means that the handle of the current connection stores unread data, so the c->recv() method is called to read the data. Otherwise, the current event is added to the // event queue, and the read event of the current connection handle is continued to be monitored if (rev->ready) {
  // Read data on the connection file descriptor n = c->recv(c, r->header_in->last, r->header_in->end - r->header_in->last);
 } else {
  n = NGX_AGAIN;
 }

 // If n is NGX_AGAIN, add the current event to the event listener and continue to listen to the read event of the current epoll handle 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;
 }

 // If n is 0, it means the client has closed the connection if (n == 0) {
  ngx_log_error(NGX_LOG_INFO, c->log, 0, "client prematurely closed connection");
 }

 // If the client closes the connection or reads abnormally, recycle the current request structure 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;
 }

 // Update the currently read data pointer r->header_in->last += n;
 return n;
}