nginx请求行读取流程

static void ngx_http_process_request_line(ngx_event_t *rev) {
  ssize_t n;
  ngx_int_t rc, rv;
  ngx_str_t host;
  ngx_connection_t *c;
  ngx_http_request_t *r;

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

  rc = NGX_AGAIN;
  for (;;) {
    if (rc == NGX_AGAIN) {
      // 这里的ngx_http_read_request_header()方法的主要作用是返回在连接上读取到的数据
      n = ngx_http_read_request_header(r);

      // n为NGX_AGAIN时，说明已经将当前事件添加到事件队列中了，因而直接返回，而NGX_ERROR则说明
      // 当前读取失败了，也直接返回
      if (n == NGX_AGAIN || n == NGX_ERROR) {
        return;
      }
    }

    // 这里主要是解析请求行的数据，比如"GET /index HTTP/1.1"
    rc = ngx_http_parse_request_line(r, r->header_in);

    // NGX_OK表示请求行的数据是完整的，并且已经解析完成
    if (rc == NGX_OK) {
      r->request_line.len = r->request_end - r->request_start;
      r->request_line.data = r->request_start;
      r->request_length = r->header_in->pos - r->request_start;
      r->method_name.len = r->method_end - r->request_start + 1;
      r->method_name.data = r->request_line.data;

      if (r->http_protocol.data) {
        r->http_protocol.len = r->request_end - r->http_protocol.data;
      }

      // 标记与参数相关的属性
      if (ngx_http_process_request_uri(r) != NGX_OK) {
        return;
      }

      if (r->host_start && r->host_end) {
        host.len = r->host_end - r->host_start;
        host.data = r->host_start;

        // 校验host，并且将host转换为小写形式
        rc = ngx_http_validate_host(&host, r->pool, 0);

        if (rc == NGX_DECLINED) {
          ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
          return;
        }

        if (rc == NGX_ERROR) {
          ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
          return;
        }

        // 设置用于处理当前请求的server和location块
        if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
          return;
        }

        r->headers_in.server = host;
      }

      // NGX_HTTP_VERSION_10表示当前请求是http 1.0，这里就是判断当前请求是否为0.9版本的请求，
      // 如果是0.9版本的请求，那么是没有请求头的
      if (r->http_version < NGX_HTTP_VERSION_10) {
        if (r->headers_in.server.len == 0 
            && ngx_http_set_virtual_server(r, &r->headers_in.server) == NGX_ERROR) {
          return;
        }

        // 对于0.9版本的请求，直接处理请求
        ngx_http_process_request(r);
        return;
      }

      // 初始化headers链表
      if (ngx_list_init(&r->headers_in.headers, 
                        r->pool, 20, sizeof(ngx_table_elt_t)) != NGX_OK) {
        ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
      }

      c->log->action = "reading client request headers";

      // 将事件的处理方法设置为ngx_http_process_request_headers()方法
      rev->handler = ngx_http_process_request_headers;
      ngx_http_process_request_headers(rev);
      return;
    }

    if (rc != NGX_AGAIN) {
      ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
      return;
    }

    /* NGX_AGAIN: a request line parsing is still incomplete */
    // 走到这里，说明返回值是NGX_AGAIN，也即读取请求行还未读取完全，如果缓冲区还有可用数据，
    // 则不做任何处理，否则继续下一次循环
    if (r->header_in->pos == r->header_in->end) {
      // 为当前request申请大块内存
      rv = ngx_http_alloc_large_header_buffer(r, 1);
      if (rv == NGX_ERROR) {
        ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
      }

      if (rv == NGX_DECLINED) {
        r->request_line.len = r->header_in->end - r->request_start;
        r->request_line.data = r->request_start;
        ngx_http_finalize_request(r, NGX_HTTP_REQUEST_URI_TOO_LARGE);
        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;

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

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

  // 走到这里，说明当前读取到的数据都已经处理完了，因而这里会进行判断，如果当前事件的ready参数为1，
  // 则表示当前连接的句柄上存储还未读取的数据，因而调用c->recv()方法读取数据，否则继续将当前事件
  // 添加到事件队列中，并且继续监听当前连接句柄的读事件
  // 这里的c->recv()方法实际指向的是ngx_unix_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;
}