Nginx源码阅读（ngx_http_process_request_line）

最新推荐文章于 2022-11-13 23:17:08 发布
最新推荐文章于 2022-11-13 23:17:08 发布
阅读量1k 收藏
点赞数
分类专栏： Nginx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz5034/article/details/81055155
版权

ngx_http_process_request_line()

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; // 当前连接对应的请求

    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
                   "http process request line");

    // 若当前读事件已经超时
    if (rev->timedout) {
        ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
        c->timedout = 1; // 设置当前连接的超时标志位为1
        ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
        return;
    }

    // NGX_AGAIN表示接收缓冲区header_in中没有未解析的数据
    rc = NGX_AGAIN;

    for ( ;; ) {

        // 若header_in中没有未解析的数据
        if (rc == NGX_AGAIN) {
            // 把内核套接字缓冲区的数据复制到header_in中
            n = ngx_http_read_request_header(r);

            // NGX_AGAIN表示若需要继续接收数据，NGX_ERROR表示客户端关闭连接或连接错误
            if (n == NGX_AGAIN || n == NGX_ERROR) {
                return;
            }
        }

        // 若header_in中有未解析的数据，用状态机解析数据
        rc = ngx_http_parse_request_line(r, r->header_in);

        // 若请求行被正确解析
        if (rc == NGX_OK) {

            /* the request line has been parsed successfully */

            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;

            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                           "http request line: \"%V\"", &r->request_line);

            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;

                rc = ngx_http_validate_host(&host, r->pool, 0);

                if (rc == NGX_DECLINED) {
                    ngx_log_error(NGX_LOG_INFO, c->log, 0,
                                  "client sent invalid host in request line");
                    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;
                }

                if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
                    return;
                }

                r->headers_in.server = host;
            }

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

                ngx_http_process_request(r);
                return;
            }


            // 初始化链表，为接收http请求头做好准备
            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;
        }

        // 若ngx_http_parse_request_line()返回错误
        if (rc != NGX_AGAIN) {

            /* there was error while a request line parsing */

            ngx_log_error(NGX_LOG_INFO, c->log, 0,
                          ngx_http_client_errors[rc - NGX_HTTP_CLIENT_ERROR]);
            ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
            return;
        }

        /* NGX_AGAIN: a request line parsing is still incomplete */

        // 若ngx_http_parse_request_line()返回NGX_AGAIN，需要判断是缓冲区大小不够，还是已读数据不够

        // 若缓冲区已经用尽
        if (r->header_in->pos == r->header_in->end) {

            // 分配另一块大缓冲区并拷贝之前的数据
            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_log_error(NGX_LOG_INFO, c->log, 0,
                              "client sent too long URI");
                ngx_http_finalize_request(r, NGX_HTTP_REQUEST_URI_TOO_LARGE);
                return;
            }
        }
    }
}

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;
 
    // 若当前请求的接收缓冲区header_in中有未解析的数据，直接返回
    if (n > 0) {
        return n;
    }
 
    // 若当前读事件已就绪
    if (rev->ready) {
        // 循环调用recv()将内核套接字缓冲区中的数据复制到header_in中
        n = c->recv(c, r->header_in->last,
                    r->header_in->end - r->header_in->last);
    } else {
        n = NGX_AGAIN;
    }
 
    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);
        }
 
        // 将读事件加入到epoll中
        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 == 0) {
        ngx_log_error(NGX_LOG_INFO, c->log, 0,
                      "client prematurely closed connection");
    }
 
    // 若客户端关闭连接或连接错误
    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;
}

ngx_http_process_request_headers()

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;

    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0,
                   "http process request header line");

    // 若当前读事件已经超时
    if (rev->timedout) {
        ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
        c->timedout = 1; // 设置当前连接的超时标志位为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 (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;
                }

                // 若大缓冲区仍然装不下整个请求头
                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_log_error(NGX_LOG_INFO, c->log, 0,
                                "client sent too long header line: \"%*s...\"",
                                len, r->header_name_start);

                    ngx_http_finalize_request(r,
                                            NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
                    return;
                }
            }

            // 把内核套接字缓冲区的数据复制到header_in中
            n = ngx_http_read_request_header(r);

            // NGX_AGAIN表示若需要继续接收数据，NGX_ERROR表示客户端关闭连接或连接错误
            if (n == NGX_AGAIN || n == NGX_ERROR) {
                return;
            }
        }

        /* the host header could change the server configuration context */
        cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

        // 若header_in中有未解析的数据，用状态机解析数据
        rc = ngx_http_parse_header_line(r, r->header_in,
                                        cscf->underscores_in_headers);

        // 返回NGX_OK，表示解析出了一行请求头
        if (rc == NGX_OK) {

            r->request_length += r->header_in->pos - r->header_name_start;

            if (r->invalid_header && cscf->ignore_invalid_headers) {

                /* there was error while a header line parsing */

                ngx_log_error(NGX_LOG_INFO, c->log, 0,
                              "client sent invalid header line: \"%*s\"",
                              r->header_end - r->header_name_start,
                              r->header_name_start);
                continue;
            }

            /* a header line has been parsed successfully */

            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;

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

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

            hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash,
                               h->lowcase_key, h->key.len);

            if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
                return;
            }

            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                           "http header: \"%V: %V\"",
                           &h->key, &h->value);

            continue;
        }

        // 返回NGX_HTTP_PARSE_HEADER_DONE，表示解析出了整个请求头
        if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

            /* a whole header has been parsed successfully */

            ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                           "http header done");

            r->request_length += r->header_in->pos - r->header_name_start;

            // 设置请求状态为NGX_HTTP_PROCESS_REQUEST_STATE
            r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;

            /* ngx_http_process_request_header() {
                   ...
                   ngx_http_set_virtual_server() {
                       ...
                       ngx_http_find_virtual_server()
                       ...
                   }
               }   
               ngx_http_process_request_header()主要做了两个方面的事情：
               一是调用ngx_http_find_virtual_server()查找虚拟服务器配置；
               二是对一些请求头做一些协议的检查 */
            rc = ngx_http_process_request_header(r);

            if (rc != NGX_OK) {
                return;
            }

            // 处理http请求
            ngx_http_process_request(r);

            return;
        }

        // 返回NGX_AGAIN，表示需要继续接收数据
        if (rc == NGX_AGAIN) {

            /* a header line parsing is still not complete */

            continue;
        }

        /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

        // 返回NGX_HTTP_PARSE_INVALID_HEADER，表示请求头解析过程中遇到错误
        ngx_log_error(NGX_LOG_INFO, c->log, 0,
                      "client sent invalid header line");

        ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
        return;
    }
}
30.Nginx HTTP之读取处理请求头函数ngx_http_process_request_headers
疯哥哥带你飞
11-16 1996
在HTTP >= 1.0的版本中，读取处理完HTTP请求行后，紧接着就应该是读取处理HTTP请求头了，Nginx使用ngx_http_process_request_headers来完成这个工作。 /* http/ngx_http_request.c */ /* 处理HTTP请求头 * param r: 待处理的HTTP请求 * return : */ static ngx_i
聊一聊nginx ngx_http_proxy_module模块
huzilinitachi的专栏
04-24 4937
        什么是代理？代理是作为中间层，作用于上下游两端。将下游的“请求”转移提交到上游，将上游的“响应”提交给下游。代理不仅在设计模式等程序设计中有比较广泛的使用，同时在大型的系统工程中使用也比较广泛，在web服务器领域，代理出现的频率也是很高的。        web服务中的代理有正向代理和反向代理两种，在大型的web服务中，反向代理是一种非常常用的技术，使用反向代理技能起到转发请求的作...
28.Nginx HTTP之读取处理请求行函数ngx_http_process_request_line
疯哥哥带你飞
11-15 595
前面我们看到，Nginx会在适当的时机(启用HTTPS时那就是在SSL握手之后)为HTTP连接的读事件注册处理函数ngx_http_process_request_line，该函数用于读取并处理HTTP请求行。 HTTP请求行格式为: [请求方法][空格][URL][空格][协议版本][回车符][换行符] 一般来说，HTTP请求行不会很长，但是依旧有可能在单次系统调用中无法读取完整的请求行，所
ngx_http_process_request_line函数解析
weixin_33709609的博客
04-28 245
处理请求行，一般的http请求过程中，ngx_http_process_request_line函数被ngx_http_wait_request_handler调用，并且在ngx_http_wait_request_handler中被设置为读事件的回调函数。在连接被accept之后，有数据到达之后会执行ngx_http_create_request函数，之后再有读事件被触发时...
ngx_http_process_request_headers函数解析
weixin_33726318的博客
07-13 301
ngx_http_process_request_headers函数被ngx_http_process_request_line函数调用，将请求头逐个放到r->headers_in.headers结构体中。由于不确定请求中一共有多少个header，所以这个函数主要功能也是在for(;;){}循环中完成，一下所有的代码都是在上述循环内部的。主要代码和解析如下：判断是否超时...
nginx源码分析（2）——http模块的初始化过程
热门推荐
架构师专栏
07-10 1万+
前一篇文章介绍了nginx的启动初始化过程，包括了所有模块的初始化过程，比如http模块、事件模块等。这里再详细介绍一下http模块的启动过程，还记得在前一篇文章中提到过ngx_conf_parse函数背后隐藏了大量的细节吗？这里就揭开这层神秘的面纱，去看看几个重要的http模块是如何初始化的。这里依然沿用上一篇文章的结构，首先来看几个重要的数据结构。 1. 重要的数据结构         1
Nginx源代码分析之HTTP请求响应基本流程（十四）
namelcx的专栏
08-29 4153
HTTP的处理请求流程我们从ngx_http_init_connection开始论述 里面注册了一个处理函数 rev->handler = ngx_http_wait_request_handler; ngx_http_wait_request_handler的参数是ngx_event_t rev,一旦有请求到达，数据已经被复制到rev->data中，这时会调用ngx_http_proc
nginx源码分析（7）——请求处理
架构师专栏
10-09 9281
在建立连接过程中，对于nginx监听到的每个客户端连接，都会将它的读事件的handler设置为ngx_http_init_request函数，这个函数就是请求处理的入口。在处理请求时，主要就是要解析http请求，比如：uri，请求行等，然后再根据请求生成响应。下面看一下nginx处理的具体过程。 1. ngx_http_init_request         在ngx_http_in
Nginx源码阅读（ngx_http_init_connection）
Jiajun Zhu
07-15 1149
ngx_http_init_connection() void ngx_http_init_connection(ngx_connection_t *c) { ngx_uint_t i; ngx_event_t *rev; struct sockaddr_in *sin; ngx_http_port_t ...
nginx源码阅读
evsqiezi
01-18 443
ngx_alloc.c 分配内存的封装 ngx_daemon_c 创建守护进程。 ngx_thread_cond.c 条件变量的封装。 ngx_recv.c   socket收的封装 ngx_send.c socket发的封装 ngx_shmem.c 共享内存的封装 ngx_socket.c socket操作的封装 ngx_thread_m
nginx源码阅读（1）
xizmi的专栏
02-20 458
ngix 源码解析
如何解读Nginx源码
qfzhaohan的博客
11-03 701
1、首先nginx是C语言编写的，你必须知识要有C语言的编程基础，否则很痛苦 2、了解web服务器，反向代理的基本知识，以及HTTP协议，TCP/IP协议的基本知识 如果你已经有丰富的经验，或者是大牛，那前面的前提就是废话，可以略过。 准备： 1、找官网，了解NGINX是做什么的，有什么特性，性能，功能，架构等 2、下载源代码，从分析main函数开始，大致了解启动流程，初始化以及一些程序的启动准备 3、建议找到request逻辑，分析下对请求的整个处理流程，有问题就先记上 4、根据分析request的.
Nginx源码阅读（模块）
Jiajun Zhu
01-21 680
每个nginx模块，都是一个ngx_module_t类型的变量。根据ngx_module_t的type，所有nginx模块可以分为5种类型： type ctx指向的数据结构 commands指向的数据结构 具体模块 NGX_CORE_MODULE ngx_core_module_t ngx_command_t ngx_core_module、ngx_e...
nginx 源码分析：http 请求处理流程——读取请求
alenliu's blog
02-25 1573
ngx_http_wait_request_handler 当客户端发送的请求到达时，epoll 监测到了一个读事件，然后调用读事件的 handler ngx_http_wait_request_handler 函数处理。它的原型如下： static void ngx_http_wait_request_handler(ngx_event_t *rev); 函数开始 c = rev-&g...
Nginx动态DNS原理及源码分析
weixin_42906485的博客
11-19 1064
一 概述 Nginx在配置上游的服务器时，支持域名配置。而且根据不同的配置，nginx提供了静态和动态解析两种方式。本文试图从代码层面分析动态dns解析是如何实现的。 静态解析 http { upstream test { server private.server1.com.cn; server private.server2.com.cn;...
Nginx源码分析 - HTTP模块篇 - HTTP Request解析过程（22）
alpha_love的博客
05-13 900
目录 一、HTTP Request解析流程图 二、源码分析 1. 等待read事件ngx_http_wait_request_handler 2. 处理头部请求行ngx_http_process_request_line 3. 处理HTTP协议的header部分ngx_http_process_request_headers 4. 处理request信息ngx_http_process_request 5. 核心分发函数ngx_http_handler 上一章我们讲解了整个Nginx的tcp
ngx_http_create_request函数解析
weixin_34249367的博客
04-20 418
ngx_http_request_t是一个重要的结构体，每一个http请求都会有自己的ngx_http_request_t结构，ngx_http_create_request函数初始化了一个ngx_http_request_t结构。主要代码和解析如下。ngx_connection_t结构中的requests字段代表了某一个连接处理的请求个数，如果在长连接模式下，一个连接可能会...
HttpProcessor
qq_25848311的博客
11-13 501
HttpProcessor内幕1. HttpProcessorHttpProcessor是什么HttpConnector中创建HttpProcessor的方法 1. HttpProcessor HttpProcessor是什么 HttpConnector中创建HttpProcessor的方法 // 创建Processor // 不超过 private HttpProcessor createProcessor() { synchronized (processors) {
nginx系列第一篇：nginx源码下载，编译和安装
hsy12342611的专栏
11-13 4901
nginx源码编译安装
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值