Nginx学习之三-ngx_http_request_t结构体

ngx_http_request_s是nginx中非常重要的一个结构体,贯穿于htpp请求处理的整个过程中。

下面解释了ngx_http_request_s结构体中与HTTP框架相关的重要的成员变量。

 

[cpp] view plaincopyprint?

 

  1. struct ngx_http_request_s {  
  2.     uint32_t                          signature;         /* "HTTP" */  
  3.   
  4.     //请求对应的客户端连接  
  5.     ngx_connection_t                 *connection;  
  6.   
  7.     //指向存放所有HTTP模块的上下文结构体的指针数组  
  8.     void                            **ctx;  
  9.     //指向请求对应的存放main级别配置结构体的指针数组  
  10.     void                            **main_conf;  
  11.     //指向请求对应的存放srv级别配置结构体的指针数组  
  12.     void                            **srv_conf;  
  13.     //指向请求对应的存放loc级别配置结构体的指针数组  
  14.     void                            **loc_conf;  
  15.   
  16.     /* 
  17.      * 在接收完http头部,第一次在业务上处理http请求时,http框架提供的处理方法是ngx_http_process_request。 
  18.      但如果该方法无法一次处理完该请求的全部业务,在归还控制权到epoll时间模块后,该请求再次被回调时, 
  19.      将通过Ngx_http_request_handler方法来处理,而这个方法中对于可读事件的处理就是调用read_event_handler处理请求。 
  20.      也就是说,http模块希望在底层处理请求的读事件时,重新实现read_event_handler方法 
  21.     */  
  22.     ngx_http_event_handler_pt         read_event_handler;  
  23.     //与上面的方法类似  
  24.     ngx_http_event_handler_pt         write_event_handler;  
  25.   
  26. #if (NGX_HTTP_CACHE)  
  27.     ngx_http_cache_t                 *cache;  
  28. #endif  
  29.   
  30.     //upstream机制用到的结构体  
  31.     ngx_http_upstream_t              *upstream;  
  32.     ngx_array_t                      *upstream_states;  
  33.                                          /* of ngx_http_upstream_state_t */  
  34.   
  35.     //这个请求的内存池  
  36.     ngx_pool_t                       *pool;  
  37.     //用于接收http请求内容的缓冲区,主要接收http头部  
  38.     ngx_buf_t                        *header_in;  
  39.   
  40.     //ngx_http_process_request_headers在接收、解析完http请求的头部后,会把解析完的每一个http头部加入到headers_in的headers链表中,同时会构造headers_in中的其他成员  
  41.     ngx_http_headers_in_t             headers_in;  
  42.     //http模块会把想要发送的http相应信息放到headers_out中,期望http框架将headers_out中的成员序列化为http响应包发送给用户  
  43.     ngx_http_headers_out_t            headers_out;  
  44.   
  45.     //接收请求中包体的数据结构  
  46.     ngx_http_request_body_t          *request_body;  
  47.   
  48.     //延迟关闭连接的时间  
  49.     time_t                            lingering_time;  
  50.     //当前请求初始化时的时间  
  51.     time_t                            start_sec;  
  52.     ngx_msec_t                        start_msec;  
  53.   
  54.     //下面的9个成员是函数ngx_http_process_request_line方法在接收、解析http请求行时解析出的信息  
  55.     ngx_uint_t                        method;//方法名  
  56.     ngx_uint_t                        http_version;//协议版本  
  57.   
  58.     ngx_str_t                         request_line;  
  59.     ngx_str_t                         uri;//用户请求中的uri  
  60.     ngx_str_t                         args;//用户请求中的url参数  
  61.     ngx_str_t                         exten;//用户请求的文件扩展名  
  62.     ngx_str_t                         unparsed_uri;//没有进行URL解码的原始请求  
  63.   
  64.     ngx_str_t                         method_name;//用户请求中的方法名字符串  
  65.     ngx_str_t                         http_protocol;//其data成员指向请求中http起始地址  
  66.   
  67.     /*表示需要发送给客户端的http响应。out中保存着由headers_out中序列化后的表示http头部的TCP流。 
  68.      * 在调用ngx_http_output_filter方法后,out中还会保存着待发送的http包体,它是实现异步发送http响应的关键。*/  
  69.     ngx_chain_t                      *out;  
  70.     /*当前请求既有可能是用户发来的请求,也可能是派生出的子请求。 
  71.      * 而main标识一系列相关的派生子请求的原始请求。 
  72.      * 一般可通过main和当前请求的地址是否相等来判断当前请求是否为用户发来的原始请求。*/  
  73.     ngx_http_request_t               *main;  
  74.     //当前请求的父请求(不一定是原始请求)  
  75.     ngx_http_request_t               *parent;  
  76.     //与subrequest子请求相关的功能  
  77.     ngx_http_postponed_request_t     *postponed;  
  78.     ngx_http_post_subrequest_t       *post_subrequest;  
  79.     //所有的子请求都是通过这个单链表链接起来的  
  80.     ngx_http_posted_request_t        *posted_requests;  
  81.   
  82.     /*全局的ngx_http_phase_engine_t结构体中定义了一个ngx_http_phase_handler_t回答方法组成的数组。 
  83.      * 而phase_handler成员则与该数组配合使用。表示请求下次应当执行phase_handler作为序列号指定的数组中的回调方法*/  
  84.     ngx_int_t                         phase_handler;  
  85.     //表示NGX_HTTP_CONTENT_PHASE阶段提供给http模块处理请求的一种方式,它指向http模块实现的请求处理方法  
  86.     ngx_http_handler_pt               content_handler;  
  87.     //在NGX_HTTP_ACCESS_PHASE节点需要判断请求是否具有访问权限时,通过access_code来传递http模块的handler回调方法的返回值,如果为0表示具备权限。否则不具备。  
  88.     ngx_uint_t                        access_code;  
  89.   
  90.     ngx_http_variable_value_t        *variables;  
  91.   
  92. #if (NGX_PCRE)  
  93.     ngx_uint_t                        ncaptures;  
  94.     int                              *captures;  
  95.     u_char                           *captures_data;  
  96. #endif  
  97.   
  98.     size_t                            limit_rate;  
  99.   
  100.     /* used to learn the Apache compatible response length without a header */  
  101.     size_t                            header_size;  
  102.   
  103.     //http请求的全部长度,包括http包体  
  104.     off_t                             request_length;  
  105.   
  106.     ngx_uint_t                        err_status;  
  107.   
  108.     ngx_http_connection_t            *http_connection;  
  109. #if (NGX_HTTP_SPDY)  
  110.     ngx_http_spdy_stream_t           *spdy_stream;  
  111. #endif  
  112.   
  113.     ngx_http_log_handler_pt           log_handler;  
  114.   
  115.     //在这个请求中如果打开了某些资源,并需要在请求结束时释放,那么需要把定义的释放资源的方法添加到这个成员  
  116.     ngx_http_cleanup_t               *cleanup;  
  117.   
  118.     unsigned                          subrequests:8;  
  119.     //引用计数一般都作用于这个请求的原始请求上  
  120.     //引用计数,每当派生出子请求时,原始请求的count成员都会加一  
  121.     unsigned                          count:8;  
  122.     //阻塞标志位,目前仅由aio使用  
  123.     unsigned                          blocked:8;  
  124.   
  125.     //标志位:为1表示蛋清请求正在使用异步IO  
  126.     unsigned                          aio:1;  
  127.   
  128.     unsigned                          http_state:4;  
  129.   
  130.     /* URI with "/." and on Win32 with "//" */  
  131.     unsigned                          complex_uri:1;  
  132.   
  133.     /* URI with "%" */  
  134.     unsigned                          quoted_uri:1;  
  135.   
  136.     /* URI with "+" */  
  137.     unsigned                          plus_in_uri:1;  
  138.   
  139.     /* URI with " " */  
  140.     unsigned                          space_in_uri:1;  
  141.   
  142.     unsigned                          invalid_header:1;  
  143.   
  144.     unsigned                          add_uri_to_alias:1;  
  145.     unsigned                          valid_location:1;  
  146.     unsigned                          valid_unparsed_uri:1;  
  147.     //标志位:为1时表示URL发生过rewrite重写  
  148.     unsigned                          uri_changed:1;  
  149.     //表示使用rewrite重写URL的次数  
  150.     unsigned                          uri_changes:4;  
  151.   
  152.     unsigned                          request_body_in_single_buf:1;  
  153.     unsigned                          request_body_in_file_only:1;  
  154.     unsigned                          request_body_in_persistent_file:1;  
  155.     unsigned                          request_body_in_clean_file:1;  
  156.     unsigned                          request_body_file_group_access:1;  
  157.     unsigned                          request_body_file_log_level:3;  
  158.   
  159.     unsigned                          subrequest_in_memory:1;  
  160.     unsigned                          waited:1;  
  161.   
  162. #if (NGX_HTTP_CACHE)  
  163.     unsigned                          cached:1;  
  164. #endif  
  165.   
  166. #if (NGX_HTTP_GZIP)  
  167.     unsigned                          gzip_tested:1;  
  168.     unsigned                          gzip_ok:1;  
  169.     unsigned                          gzip_vary:1;  
  170. #endif  
  171.   
  172.     unsigned                          proxy:1;  
  173.     unsigned                          bypass_cache:1;  
  174.     unsigned                          no_cache:1;  
  175.   
  176.     /* 
  177.      * instead of using the request context data in 
  178.      * ngx_http_limit_conn_module and ngx_http_limit_req_module 
  179.      * we use the single bits in the request structure 
  180.      */  
  181.     unsigned                          limit_conn_set:1;  
  182.     unsigned                          limit_req_set:1;  
  183.   
  184. #if 0  
  185.     unsigned                          cacheable:1;  
  186. #endif  
  187.   
  188.     unsigned                          pipeline:1;  
  189.     unsigned                          chunked:1;  
  190.     unsigned                          header_only:1;  
  191.     //标志位,为1表示当前请求时keepalive请求  
  192.     unsigned                          keepalive:1;  
  193.     //延迟关闭标志位  
  194.     unsigned                          lingering_close:1;  
  195.     //标志位:为1表示正在丢弃http请求中的包体  
  196.     unsigned                          discard_body:1;  
  197.     //标志位:为1表示请求的当前状态是在做内部跳转  
  198.     unsigned                          internal:1;  
  199.     unsigned                          error_page:1;  
  200.     unsigned                          ignore_content_encoding:1;  
  201.     unsigned                          filter_finalize:1;  
  202.     unsigned                          post_action:1;  
  203.     unsigned                          request_complete:1;  
  204.     unsigned                          request_output:1;  
  205.     //标志位:为1表示发生给客户端的http响应头已经发送  
  206.     unsigned                          header_sent:1;  
  207.     unsigned                          expect_tested:1;  
  208.     unsigned                          root_tested:1;  
  209.     unsigned                          done:1;  
  210.     unsigned                          logged:1;  
  211.   
  212.     //标志位,表示缓冲中是否有待发送内容  
  213.     unsigned                          buffered:4;  
  214.   
  215.     unsigned                          main_filter_need_in_memory:1;  
  216.     unsigned                          filter_need_in_memory:1;  
  217.     unsigned                          filter_need_temporary:1;  
  218.     unsigned                          allow_ranges:1;  
  219.   
  220. #if (NGX_STAT_STUB)  
  221.     unsigned                          stat_reading:1;  
  222.     unsigned                          stat_writing:1;  
  223. #endif  
  224.   
  225.     /* used to parse HTTP headers */  
  226.   
  227.     //状态机解析http时使用state来表示当前的解析状态,需要检查是否构成完成的http请求行  
  228.     ngx_uint_t                        state;  
  229.   
  230.     ngx_uint_t                        header_hash;  
  231.     ngx_uint_t                        lowcase_index;  
  232.     u_char                            lowcase_header[NGX_HTTP_LC_HEADER_LEN];  
  233.   
  234.     u_char                           *header_name_start;  
  235.     u_char                           *header_name_end;  
  236.     u_char                           *header_start;  
  237.     u_char                           *header_end;  
  238.   
  239.     /* 
  240.      * a memory that can be reused after parsing a request line 
  241.      * via ngx_http_ephemeral_t 
  242.      */  
  243.   
  244.     u_char                           *uri_start;  
  245.     u_char                           *uri_end;  
  246.     u_char                           *uri_ext;  
  247.     u_char                           *args_start;  
  248.     u_char                           *request_start;  
  249.     u_char                           *request_end;  
  250.     u_char                           *method_end;  
  251.     u_char                           *schema_start;  
  252.     u_char                           *schema_end;  
  253.     u_char                           *host_start;  
  254.     u_char                           *host_end;  
  255.     u_char                           *port_start;  
  256.     u_char                           *port_end;  
  257.   
  258.     unsigned                          http_minor:16;  
  259.     unsigned                          http_major:16;  
  260. };  
时间: 2024-10-22 17:02:33

Nginx学习之三-ngx_http_request_t结构体的相关文章

《从缺陷中学习C/C++》——6.16 结构体成员内存对齐问题

6.16 结构体成员内存对齐问题 从缺陷中学习C/C++ 代码示例 struct{ char flag; int i; } foo; int main() { foo.flag = 'T'; int pi = (int )(&foo.flag + 1); *pi = 0x01020304; printf("flag=%c, i=%x\n", foo.flag, foo.i); return 0; } 现象&后果 代码中定义了一个结构体,包括一个字符成员flag和整型成员

《从零开始学Swift》学习笔记(Day 25)——类和结构体定义

 原创文章,欢迎转载.转载请注明:关东升的博客 Swift中的类和结构体定义的语法是非常相似的.类使用class关键词定义类,使用struct关键词定义结构体,它们的语法格式如下: class 类名 {     定义类的成员 } struct 结构体名 {     定义结构体的成员 } 从语法格式上看,Swift中的类和结构体的定义更类似于Java语法,不需要像C++和Objective-C那样把接口部分和实现部分放到不同的文件中. 下面来看一个示例: class Employee { //

[MySQL学习] Innodb锁系统(3)关键结构体及函数

1.锁对象的定义: 关键结构体: UNIV_INTERN lock_sys_t* lock_sys = NULL; lock_sys是一个全局变量,用于控制整个Innodb锁系统的全部锁结构,其对应的结构体为lock_sys_t,该结构体只包含两个成员: struct lock_sys_struct{     hash_table_t* rec_hash;     ulint rec_num; }; 从函数lock_rec_create可以很容易看出这两个变量的作用: quoted code:

《从零开始学Swift》学习笔记(Day 30)——选择类还是结构体呢?

原创文章,欢迎转载.转载请注明:关东升的博客   类和结构体非常相似,很多情况下没有区别.如果你是设计人员在进行系统设计时候,是将某种类型设计成为类还是结构体?  类和结构体异同: 类和结构体都有如下功能: 定义存储属性 定义方法 定义下标 定义构造函数 定义扩展 实现协议  只有类才有的功能: 能够继承另外一个类 能够核对运行期对象的类型 析构对象释放资源 引用计数允许一个实例有多个引用  选择的原则: 结构体是值类型,每一个实例没有独一无二的标识,下面两个数组实例本质上没有区别,他们可以互相

Swift中的类class与结构体struct体学习笔记_Swift

一.引言Swift中的类与结构体十分相似,和Objective-C不同的事,Swift中的结构体不仅可以定义属性,也可以像类一样为其定义方法. Swift中的类与结构体有如下相似点: 1.定义属性来存储值. 2.定义函数来提供功能. 3.通过定义下标语法使用下标的方式取值. 4.定义构造方法来对其进行初始化. 5.通过扩展来在原始基础上添加功能. 6.通过协议来定义实现标准. 当然类和结构体也有许多不同点,下面这些功能是类独有的,结构体没有: 1.通过继承来创建类的子类. 2.在运行时允许对类的

C语言中的结构体的入门学习教程_C 语言

C语言中数组允许定义类型的变量,可容纳相同类型的多个数据项,但结构体在C语言编程中,它允许定义不同种类的数据项可供其他用户定义的数据类型. 结构是用来代表一个记录,假设要跟踪图书馆的书籍.可能要跟踪有关每本书以下属性: Title - 标题 Author - 作者 Subject - 科目 Book ID - 编号 定义结构体定义一个结构体,必须使用结构体的struct语句.该struct语句定义了一个新的数据类型,程序不止一个成员.struct语句的格式是这样的: struct [struct

数据结构学习(结构体复习)

结构体 为什么会出现结构体 为了表示一些复杂的数据,而普通的基本类型变量无法满足要求 什么叫做结构体 结构体是用户根据实际需要自己定义的复合数据类型 如何使用结构体 两种方式: struct Student st = {1000,"zhangxu",20}; struct Student *pst = &st; 1. St.sid 2. Pst->sid Pst所指向的结构体变量中的sid这个成员 注意事项 1.结构体变量不能加减乘除,但可以相互赋值 2.普通结构体变量和

Nginx学习笔记(六) 源码分析&启动过程

涉及到的基本函数 源码: 1 /* 2 * Copyright (C) Igor Sysoev 3 * Copyright (C) Nginx, Inc. 4 */ 5 6 7 #include <ngx_config.h> 8 #include <ngx_core.h> 9 #include <nginx.h> 10 11 12 static ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle); 13 sta

Nginx学习笔记(二) Nginx--connection&amp;request

在Nginx中,主要包括了连接与处理两部分. connection 在src/core文件夹下包含有connection的源文件,Ngx_connection.h/Ngx_connection.c中可以找到SOCK_STREAM,也就是说Nginx是基于TCP连接的. 连接过程 对于应用程序,首先第一步肯定是加载并解析配置文件,Nginx同样如此,这样可以获得需要监听的端口和IP地址.之后,Nginx就要创建master进程,并建立socket,这样就可以创建多个worker进程来,每个work