Nginx learning three-ngx_http_request_t structure

Excerpted from: http://blog.csdn.net/xiajun07061225/article/details/9189505 Jiang Yuyanyun’s blog

ngx_http_request_s is a very important structure in nginx, which runs through the entire process of http request processing.

The following explains the important member variables related to the HTTP framework in the ngx_http_request_s structure.

[cpp] view plain copy print?

1. structngx_http_request_s {
2. uint32_t signature; /* "HTTP" */
4. //Request the corresponding client connection
5. ngx_connection_t *connection;
7. //Array of pointers to context structures that store all HTTP modules
8.                                                                            //Array of pointers pointing to the main level configuration structure corresponding to the request
9. void **main_conf;
10. //Pointer to the srv level configuration structure corresponding to the request Array
11. void                                                       Pointer array of loc level configuration structure
12. void loc_conf;
13. /*
15. But if this method cannot handle all the business of the request at one time, after returning control to the epoll time module, when the request is called back again,
16. will be processed through the Ngx_http_request_handler method, The processing of readable events in this method is to call read_event_handler to process the request.
17. That is to say, the http module hopes to reimplement the read_event_handler method when processing the requested read event at the bottom layer
18. */
19. ngx _http_event_handler_pt                                  read_event_handler;                                          /Similar to the above method
20. ngx_http_event_handler_pt write_event_handler;
22. #if (NGX_HTTP_CACHE)
23. ngx_http_cache_t *cache;
24. #endif
/
25. // The structure used by the upstream mechanism ngx_http_upstream_t*upstream; ngx_array_t*upstream_states;
27. *pool;
28. //Buffer used to receive http request content, mainly receiving http headers Department
30. ngx_buf_t *header_in;
31. After http_process_request_headers receives and parses the headers of the http request, it will add each parsed http header to headers_in. In the headers linked list, other members in headers_in will be constructed at the same time
32. ngx_http_headers_in_t headers_in;
33. //The http module will put the http corresponding information you want to send into headers_out , expecting the http framework to headers_out The members in are serialized into http response packets and sent to the user
34. ngx_http_headers_out_t headers_out;
36. //Receive request The data structure of the body
37. ngx_http_request_body_t * Request_body;
39. // Delaying the time to close the connection
Time_t
40. lingering_time;
// The current request initialization time
43.                                                                                                                                                 
45. //The following 9 members are the information parsed by the function ngx_http_process_request_line method when receiving and parsing the http request line
46. ngx_uint_t ngx_uint_t method; //Method name
47. ngx_uint_t http_version ; 议 // Protocol version
49. ngx_str_t request_line;
50. ngx_str_t uri; // Uri
51. ngx_str_t args in the user request; // User request request The url parameter in the middle
ngx_str_t exten;
52. // The file requested by the user expansion name ngx_str_t unparsed_uri; // The original request without URL decoding
53. ngx_str_t ngx_str_t method_name;//Method name string in user request
54. ngx_str_t                    http_protocol;//The data member points to the http starting address in the request
55.                                                                                          /* represents the http response that needs to be sent to the client. out holds the TCP stream representing the http header serialized in headers_out.
56. * After calling the ngx_http_output_filter method, the http package body to be sent will also be saved in out, which is the key to asynchronously sending http responses. */
57. ngx_chain_t *out;
58. /*The current request may be a request sent by the user or a derived sub-request.
59. * And main identifies the original request of a series of related derived sub-requests.通过 可*generally can determine whether the current request is the original request sent by the user through the same requests.*/
60. ngx_http_request_t *main;
61. //The parent request of the current request (not necessarily the original request)
62. ngx_http_request_t *parent;
63. // Functions related to subrequest sub-requests
64. ngx_http_postponed_request_t *postponed;
65. ngx_http_post_subrequest_t *post_subrequest;
66. //All sub-requests are linked through this singly linked list
67. ngx_http_posted_request_t *posted_requests;
69. /*An ngx_http_phase_handler_t answer method is defined in the global ngx_http_phase_engine_t structure Array composed of. H p*and Phase_handler members are used in conjunction with the array. Indicates that the request should execute phase_handler next time as the callback method in the array specified by the sequence number */
70. ngx_int_t The NGX_HTTP_CONTENT_PHASE phase provides a way for the http module to process requests. It points to the request processing method implemented by the http module
71. ngx_http_handler_pt content_handler;
72. //When the NGX_HTTP_ACCESS_PHASE node needs to determine whether the request has access permissions , pass access_code to pass the return of the handler callback method of the http module Value, if it is 0, it means it has permission. Otherwise it is not available.  
73.     ngx_uint_t                        access_code;  
74.   
75.     ngx_http_variable_value_t        *variables;  
76.   
77. #if (NGX_PCRE)  
78.     ngx_uint_t                        ncaptures;  
79.     int                              *captures;  
80.     u_char                           *captures_data;  
81. #endif  
82.   
83.     size_t                            limit_rate;  
84.   
85.     /* used to learn the Apache compatible response length without a header */  
86.     size_t                            header_size;  
87.   
88.     //http请求的全部长度，包括http包体  
89.     off_t                             request_length;  
90.   
91.     ngx_uint_t                        err_status;  
92.   
93.     ngx_http_connection_t            *http_connection;  
94. #if (NGX_HTTP_SPDY)  
95.     ngx_http_spdy_stream_t           *spdy_stream;  
96. #endif  
97.   
98.     ngx_http_log_handler_pt           log_handler;  
99.   
100.     //在这个请求中如果打开了某些资源，并需要在请求结束时释放，那么需要把定义的释放资源的方法添加到这个成员  
101.     ngx_http_cleanup_t               *cleanup;  
102.   
103.     unsigned                          subrequests:8;  
104.     //引用计数一般都作用于这个请求的原始请求上  
105.     //引用计数，每当派生出子请求时，原始请求的count成员都会加一  
106.     unsigned                          count:8;  
107.     //阻塞标志位，目前仅由aio使用  
N unsigned blocked: 8;
110. // logo bit: 1 indicates that the egg white request is using asynchronous IO
unsigned AIO: 1;
unsigned http_state:4;
115. /* URI with "/." and on Win32 with "//" */
unsigned complex_uri:1;
118.                                                                                                                          
                                                                                                                                                                            plus_in_uri:1;
121. /* URI with " " space_in_uri:1;
122. unsigned invalid_header:1;
124. unsigned unsigned add_uri_to_alias:1; unsigned valid_location:1;
125. unsigned unsigned valid_unparsed_uri:1;
126. //Flag bit: When it is 1, it means that the URL has been rewritten
127. N unsigned uri_changed: 1;
128. // indicate the number of times using reWrite to rewrite the URL
UNSIGNED URI_CHANGES: 4;
129. unsigned request_body_in_file_only:1;
131.     unsigned                          request_body_in_persistent_file:1;  
132.     unsigned                          request_body_in_clean_file:1;  
133.     unsigned                          request_body_file_group_access:1;  
134.     unsigned                          request_body_file_log_level:3;  
135.   
136.     unsigned                          subrequest_in_memory:1;  
137.     unsigned                          waited:1;  
138.   
139. #if (NGX_HTTP_CACHE)  
140.     unsigned                          cached:1;  
141. #endif  
142.   
143. #if (NGX_HTTP_GZIP)  
144.     unsigned                          gzip_tested:1;  
145.     unsigned                          gzip_ok:1;  
146.     unsigned                          gzip_vary:1;  
147. #endif  
148.   
149.     unsigned                          proxy:1;  
150.     unsigned                          bypass_cache:1;  
151.     unsigned                          no_cache:1;  
152.   
153.     /* 
154.      * instead of using the request context data in 
155.      * ngx_http_limit_conn_module and ngx_http_limit_req_module 
156.      * we use the single bits in the request structure 
157.      */  
158.     unsigned                          limit_conn_set:1;  
159.     unsigned                          limit_req_set:1;  
160.   
161. #if 0  
N unsigned cacheable: 1;
163. #Endif
unsigned pipeline: 1;
unsigned chunked: 1;
unsigned header_only: 1;
168. //Flag bit, 1 indicates a keepalive request during the current request
unsigned keepalive:1;
170. //Delayed closing flag
unsigned lingering_close:1 ;
172. //Flag bit: 1 indicates that the package body in the http request is being discarded
unsigned                                                      
//Flag bit: 1 indicates the requested current The status is doing an internal jump
174. unsigned                                     error_page:1;
175. unsigned unsigned filter_finalize:1;
176. unsigned                                  post_action:1;                   request_output: 1;                                                                                                                                                                                                    
177.  unsigned header_sent:1;
178. unsigned expect_tested:1;
179. unsigned root_tested:1;
180.                                                                                                                                                                                                                                       done:1;
181. //Flag bit, indicating whether there is content to be sent in the buffer
183. unsigned
184. unsigned unsigned main_filter_need_in_memory:1;
185. filter_need_in_memory:1;
186. unsigned filter_need_temporary:1;
187. unsigned                           allow_ranges:1; (NGX_STAT_STUB)
unsigned stat_reading:1;
unsigned          stat_writing:1;                                                                      */
//The state machine uses state to represent the current parsing status when parsing http. You need to check whether it constitutes a completed http request line
193. ngx_uint_ t                                                                          state;
194. ngx_uint_t header_hash;
195. ngx_uint_t lowcase_index;
196. u_char u_char lowcase_header[NGX_HTTP_LC_HEADER_LEN]; u_char                                         *header_name_start;       u_char                                                                                                           ;
198.     /* 
199.      * a memory that can be reused after parsing a request line 
200.      * via ngx_http_ephemeral_t 
201.      */  
202.   
203.     u_char                           *uri_start;  
204.     u_char                           *uri_end;  
205.     u_char                           *uri_ext;  
206.     u_char                           *args_start;  
207.     u_char                           *request_start;  
208.     u_char                           *request_end;  
209.     u_char                           *method_end;  
210.     u_char                           *schema_start;  
211.     u_char                           *schema_end;  
212.     u_char                           *host_start;  
213.     u_char                           *host_end;  
214.     u_char                           *port_start;  
215.     u_char                           *port_end;  
216.   
217.     unsigned                          http_minor:16;  
218.     unsigned                          http_major:16;  
219. }; 

以上就介绍了 Nginx学习之三-ngx_http_request_t结构体，包括了方面的内容，希望对PHP教程有兴趣的朋友有所帮助。