Struct nginx::ngx_http_request_s

#[repr(C)]pub struct ngx_http_request_s {
    pub signature: u32,
    pub connection: *mut ngx_connection_t,
    pub ctx: *mut *mut c_void,
    pub main_conf: *mut *mut c_void,
    pub srv_conf: *mut *mut c_void,
    pub loc_conf: *mut *mut c_void,
    pub read_event_handler: ngx_http_event_handler_pt,
    pub write_event_handler: ngx_http_event_handler_pt,
    pub cache: *mut ngx_http_cache_t,
    pub upstream: *mut ngx_http_upstream_t,
    pub upstream_states: *mut ngx_array_t,
    pub pool: *mut ngx_pool_t,
    pub header_in: *mut ngx_buf_t,
    pub headers_in: ngx_http_headers_in_t,
    pub headers_out: ngx_http_headers_out_t,
    pub request_body: *mut ngx_http_request_body_t,
    pub lingering_time: time_t,
    pub start_sec: time_t,
    pub start_msec: ngx_msec_t,
    pub method: ngx_uint_t,
    pub http_version: ngx_uint_t,
    pub request_line: ngx_str_t,
    pub uri: ngx_str_t,
    pub args: ngx_str_t,
    pub exten: ngx_str_t,
    pub unparsed_uri: ngx_str_t,
    pub method_name: ngx_str_t,
    pub http_protocol: ngx_str_t,
    pub schema: ngx_str_t,
    pub out: *mut ngx_chain_t,
    pub main: *mut ngx_http_request_t,
    pub parent: *mut ngx_http_request_t,
    pub postponed: *mut ngx_http_postponed_request_t,
    pub post_subrequest: *mut ngx_http_post_subrequest_t,
    pub posted_requests: *mut ngx_http_posted_request_t,
    pub phase_handler: ngx_int_t,
    pub content_handler: ngx_http_handler_pt,
    pub access_code: ngx_uint_t,
    pub variables: *mut ngx_http_variable_value_t,
    pub ncaptures: ngx_uint_t,
    pub captures: *mut c_int,
    pub captures_data: *mut u_char,
    pub limit_rate: size_t,
    pub limit_rate_after: size_t,
    pub header_size: size_t,
    pub request_length: off_t,
    pub err_status: ngx_uint_t,
    pub http_connection: *mut ngx_http_connection_t,
    pub stream: *mut ngx_http_v2_stream_t,
    pub log_handler: ngx_http_log_handler_pt,
    pub cleanup: *mut ngx_http_cleanup_t,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16], u16>,
    pub state: ngx_uint_t,
    pub header_hash: ngx_uint_t,
    pub lowcase_index: ngx_uint_t,
    pub lowcase_header: [u_char; 32],
    pub header_name_start: *mut u_char,
    pub header_name_end: *mut u_char,
    pub header_start: *mut u_char,
    pub header_end: *mut u_char,
    pub uri_start: *mut u_char,
    pub uri_end: *mut u_char,
    pub uri_ext: *mut u_char,
    pub args_start: *mut u_char,
    pub request_start: *mut u_char,
    pub request_end: *mut u_char,
    pub method_end: *mut u_char,
    pub schema_start: *mut u_char,
    pub schema_end: *mut u_char,
    pub host_start: *mut u_char,
    pub host_end: *mut u_char,
    pub port_start: *mut u_char,
    pub port_end: *mut u_char,
    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4], u16>,
    pub __bindgen_padding_0: u32,
}

Fields

signature: u32

connection: *mut ngx_connection_t

ctx: *mut *mut c_void

main_conf: *mut *mut c_void

srv_conf: *mut *mut c_void

loc_conf: *mut *mut c_void

read_event_handler: ngx_http_event_handler_pt

write_event_handler: ngx_http_event_handler_pt

cache: *mut ngx_http_cache_t

upstream: *mut ngx_http_upstream_t

upstream_states: *mut ngx_array_t

pool: *mut ngx_pool_t

header_in: *mut ngx_buf_t

headers_in: ngx_http_headers_in_t

headers_out: ngx_http_headers_out_t

request_body: *mut ngx_http_request_body_t

lingering_time: time_t

start_sec: time_t

start_msec: ngx_msec_t

method: ngx_uint_t

http_version: ngx_uint_t

request_line: ngx_str_t

uri: ngx_str_t

args: ngx_str_t

exten: ngx_str_t

unparsed_uri: ngx_str_t

method_name: ngx_str_t

http_protocol: ngx_str_t

schema: ngx_str_t

out: *mut ngx_chain_t

main: *mut ngx_http_request_t

parent: *mut ngx_http_request_t

postponed: *mut ngx_http_postponed_request_t

post_subrequest: *mut ngx_http_post_subrequest_t

posted_requests: *mut ngx_http_posted_request_t

phase_handler: ngx_int_t

content_handler: ngx_http_handler_pt

access_code: ngx_uint_t

variables: *mut ngx_http_variable_value_t

ncaptures: ngx_uint_t

captures: *mut c_int

captures_data: *mut u_char

limit_rate: size_t

limit_rate_after: size_t

header_size: size_t

request_length: off_t

err_status: ngx_uint_t

http_connection: *mut ngx_http_connection_t

stream: *mut ngx_http_v2_stream_t

log_handler: ngx_http_log_handler_pt

cleanup: *mut ngx_http_cleanup_t

_bitfield_1: __BindgenBitfieldUnit<[u8; 16], u16>

state: ngx_uint_t

header_hash: ngx_uint_t

lowcase_index: ngx_uint_t

lowcase_header: [u_char; 32]

header_name_start: *mut u_char

header_name_end: *mut u_char

header_start: *mut u_char

header_end: *mut u_char

uri_start: *mut u_char

uri_end: *mut u_char

uri_ext: *mut u_char

args_start: *mut u_char

request_start: *mut u_char

request_end: *mut u_char

method_end: *mut u_char

schema_start: *mut u_char

schema_end: *mut u_char

host_start: *mut u_char

host_end: *mut u_char

port_start: *mut u_char

port_end: *mut u_char

_bitfield_2: __BindgenBitfieldUnit<[u8; 4], u16>

__bindgen_padding_0: u32

Implementations

impl ngx_http_request_s

pub fn count(&self) -> c_uint

pub fn set_count(&mut self, val: c_uint)

pub fn subrequests(&self) -> c_uint

pub fn set_subrequests(&mut self, val: c_uint)

pub fn blocked(&self) -> c_uint

pub fn set_blocked(&mut self, val: c_uint)

pub fn aio(&self) -> c_uint

pub fn set_aio(&mut self, val: c_uint)

pub fn http_state(&self) -> c_uint

pub fn set_http_state(&mut self, val: c_uint)

pub fn complex_uri(&self) -> c_uint

pub fn set_complex_uri(&mut self, val: c_uint)

pub fn quoted_uri(&self) -> c_uint

pub fn set_quoted_uri(&mut self, val: c_uint)

pub fn plus_in_uri(&self) -> c_uint

pub fn set_plus_in_uri(&mut self, val: c_uint)

pub fn space_in_uri(&self) -> c_uint

pub fn set_space_in_uri(&mut self, val: c_uint)

pub fn invalid_header(&self) -> c_uint

pub fn set_invalid_header(&mut self, val: c_uint)

pub fn add_uri_to_alias(&self) -> c_uint

pub fn set_add_uri_to_alias(&mut self, val: c_uint)

pub fn valid_location(&self) -> c_uint

pub fn set_valid_location(&mut self, val: c_uint)

pub fn valid_unparsed_uri(&self) -> c_uint

pub fn set_valid_unparsed_uri(&mut self, val: c_uint)

pub fn uri_changed(&self) -> c_uint

pub fn set_uri_changed(&mut self, val: c_uint)

pub fn uri_changes(&self) -> c_uint

pub fn set_uri_changes(&mut self, val: c_uint)

pub fn request_body_in_single_buf(&self) -> c_uint

pub fn set_request_body_in_single_buf(&mut self, val: c_uint)

pub fn request_body_in_file_only(&self) -> c_uint

pub fn set_request_body_in_file_only(&mut self, val: c_uint)

pub fn request_body_in_persistent_file(&self) -> c_uint

pub fn set_request_body_in_persistent_file(&mut self, val: c_uint)

pub fn request_body_in_clean_file(&self) -> c_uint

pub fn set_request_body_in_clean_file(&mut self, val: c_uint)

pub fn request_body_file_group_access(&self) -> c_uint

pub fn set_request_body_file_group_access(&mut self, val: c_uint)

pub fn request_body_file_log_level(&self) -> c_uint

pub fn set_request_body_file_log_level(&mut self, val: c_uint)

pub fn request_body_no_buffering(&self) -> c_uint

pub fn set_request_body_no_buffering(&mut self, val: c_uint)

pub fn subrequest_in_memory(&self) -> c_uint

pub fn set_subrequest_in_memory(&mut self, val: c_uint)

pub fn waited(&self) -> c_uint

pub fn set_waited(&mut self, val: c_uint)

pub fn cached(&self) -> c_uint

pub fn set_cached(&mut self, val: c_uint)

pub fn gzip_tested(&self) -> c_uint

pub fn set_gzip_tested(&mut self, val: c_uint)

pub fn gzip_ok(&self) -> c_uint

pub fn set_gzip_ok(&mut self, val: c_uint)

pub fn gzip_vary(&self) -> c_uint

pub fn set_gzip_vary(&mut self, val: c_uint)

pub fn realloc_captures(&self) -> c_uint

pub fn set_realloc_captures(&mut self, val: c_uint)

pub fn proxy(&self) -> c_uint

pub fn set_proxy(&mut self, val: c_uint)

pub fn bypass_cache(&self) -> c_uint

pub fn set_bypass_cache(&mut self, val: c_uint)

pub fn no_cache(&self) -> c_uint

pub fn set_no_cache(&mut self, val: c_uint)

pub fn limit_conn_status(&self) -> c_uint

pub fn set_limit_conn_status(&mut self, val: c_uint)

pub fn limit_req_status(&self) -> c_uint

pub fn set_limit_req_status(&mut self, val: c_uint)

pub fn limit_rate_set(&self) -> c_uint

pub fn set_limit_rate_set(&mut self, val: c_uint)

pub fn limit_rate_after_set(&self) -> c_uint

pub fn set_limit_rate_after_set(&mut self, val: c_uint)

pub fn pipeline(&self) -> c_uint

pub fn set_pipeline(&mut self, val: c_uint)

pub fn chunked(&self) -> c_uint

pub fn set_chunked(&mut self, val: c_uint)

pub fn header_only(&self) -> c_uint

pub fn set_header_only(&mut self, val: c_uint)

pub fn expect_trailers(&self) -> c_uint

pub fn set_expect_trailers(&mut self, val: c_uint)

pub fn keepalive(&self) -> c_uint

pub fn set_keepalive(&mut self, val: c_uint)

pub fn lingering_close(&self) -> c_uint

pub fn set_lingering_close(&mut self, val: c_uint)

pub fn discard_body(&self) -> c_uint

pub fn set_discard_body(&mut self, val: c_uint)

pub fn reading_body(&self) -> c_uint

pub fn set_reading_body(&mut self, val: c_uint)

pub fn internal(&self) -> c_uint

pub fn set_internal(&mut self, val: c_uint)

pub fn error_page(&self) -> c_uint

pub fn set_error_page(&mut self, val: c_uint)

pub fn filter_finalize(&self) -> c_uint

pub fn set_filter_finalize(&mut self, val: c_uint)

pub fn post_action(&self) -> c_uint

pub fn set_post_action(&mut self, val: c_uint)

pub fn request_complete(&self) -> c_uint

pub fn set_request_complete(&mut self, val: c_uint)

pub fn request_output(&self) -> c_uint

pub fn set_request_output(&mut self, val: c_uint)

pub fn header_sent(&self) -> c_uint

pub fn set_header_sent(&mut self, val: c_uint)

pub fn expect_tested(&self) -> c_uint

pub fn set_expect_tested(&mut self, val: c_uint)

pub fn root_tested(&self) -> c_uint

pub fn set_root_tested(&mut self, val: c_uint)

pub fn done(&self) -> c_uint

pub fn set_done(&mut self, val: c_uint)

pub fn logged(&self) -> c_uint

pub fn set_logged(&mut self, val: c_uint)

pub fn buffered(&self) -> c_uint

pub fn set_buffered(&mut self, val: c_uint)

pub fn main_filter_need_in_memory(&self) -> c_uint

pub fn set_main_filter_need_in_memory(&mut self, val: c_uint)

pub fn filter_need_in_memory(&self) -> c_uint

pub fn set_filter_need_in_memory(&mut self, val: c_uint)

pub fn filter_need_temporary(&self) -> c_uint

pub fn set_filter_need_temporary(&mut self, val: c_uint)

pub fn preserve_body(&self) -> c_uint

pub fn set_preserve_body(&mut self, val: c_uint)

pub fn allow_ranges(&self) -> c_uint

pub fn set_allow_ranges(&mut self, val: c_uint)

pub fn subrequest_ranges(&self) -> c_uint

pub fn set_subrequest_ranges(&mut self, val: c_uint)

pub fn single_range(&self) -> c_uint

pub fn set_single_range(&mut self, val: c_uint)

pub fn disable_not_modified(&self) -> c_uint

pub fn set_disable_not_modified(&mut self, val: c_uint)

pub fn stat_reading(&self) -> c_uint

pub fn set_stat_reading(&mut self, val: c_uint)

pub fn stat_writing(&self) -> c_uint

pub fn set_stat_writing(&mut self, val: c_uint)

pub fn stat_processing(&self) -> c_uint

pub fn set_stat_processing(&mut self, val: c_uint)

pub fn background(&self) -> c_uint

pub fn set_background(&mut self, val: c_uint)

pub fn health_check(&self) -> c_uint

pub fn set_health_check(&mut self, val: c_uint)

pub fn new_bitfield_1(
    count: c_uint,
    subrequests: c_uint,
    blocked: c_uint,
    aio: c_uint,
    http_state: c_uint,
    complex_uri: c_uint,
    quoted_uri: c_uint,
    plus_in_uri: c_uint,
    space_in_uri: c_uint,
    invalid_header: c_uint,
    add_uri_to_alias: c_uint,
    valid_location: c_uint,
    valid_unparsed_uri: c_uint,
    uri_changed: c_uint,
    uri_changes: c_uint,
    request_body_in_single_buf: c_uint,
    request_body_in_file_only: c_uint,
    request_body_in_persistent_file: c_uint,
    request_body_in_clean_file: c_uint,
    request_body_file_group_access: c_uint,
    request_body_file_log_level: c_uint,
    request_body_no_buffering: c_uint,
    subrequest_in_memory: c_uint,
    waited: c_uint,
    cached: c_uint,
    gzip_tested: c_uint,
    gzip_ok: c_uint,
    gzip_vary: c_uint,
    realloc_captures: c_uint,
    proxy: c_uint,
    bypass_cache: c_uint,
    no_cache: c_uint,
    limit_conn_status: c_uint,
    limit_req_status: c_uint,
    limit_rate_set: c_uint,
    limit_rate_after_set: c_uint,
    pipeline: c_uint,
    chunked: c_uint,
    header_only: c_uint,
    expect_trailers: c_uint,
    keepalive: c_uint,
    lingering_close: c_uint,
    discard_body: c_uint,
    reading_body: c_uint,
    internal: c_uint,
    error_page: c_uint,
    filter_finalize: c_uint,
    post_action: c_uint,
    request_complete: c_uint,
    request_output: c_uint,
    header_sent: c_uint,
    expect_tested: c_uint,
    root_tested: c_uint,
    done: c_uint,
    logged: c_uint,
    buffered: c_uint,
    main_filter_need_in_memory: c_uint,
    filter_need_in_memory: c_uint,
    filter_need_temporary: c_uint,
    preserve_body: c_uint,
    allow_ranges: c_uint,
    subrequest_ranges: c_uint,
    single_range: c_uint,
    disable_not_modified: c_uint,
    stat_reading: c_uint,
    stat_writing: c_uint,
    stat_processing: c_uint,
    background: c_uint,
    health_check: c_uint
) -> __BindgenBitfieldUnit<[u8; 16], u16>

pub fn http_minor(&self) -> c_uint

pub fn set_http_minor(&mut self, val: c_uint)

pub fn http_major(&self) -> c_uint

pub fn set_http_major(&mut self, val: c_uint)

pub fn new_bitfield_2(
    http_minor: c_uint,
    http_major: c_uint
) -> __BindgenBitfieldUnit<[u8; 4], u16>

Trait Implementations

impl Clone for ngx_http_request_s

fn clone(&self) -> ngx_http_request_s

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ngx_http_request_s

impl Debug for ngx_http_request_s

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.