Google Git
Sign in
android/toolchain/rustc/e40e7362ba4208d45fb88525361a7de2fad4bb91/./vendor/libnghttp2-sys/src/lib.rs
blob: b7bcdd93c3879cd20dfb0295f87b0409323e5d1b [file]
#![allow(bad_style)]
/* automatically generated by rust-bindgen, then hand edited */
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_session {
_unused: [u8; 0],
}
/// @struct
///
/// This struct is what `nghttp2_version()` returns. It holds
/// information about the particular nghttp2 version.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_info {
/// Age of this struct. This instance of nghttp2 sets it to
/// :macro:`NGHTTP2_VERSION_AGE` but a future version may bump it and
/// add more struct fields at the bottom
pub age: ::std::os::raw::c_int,
/// the :macro:`NGHTTP2_VERSION_NUM` number (since age ==1)
pub version_num: ::std::os::raw::c_int,
/// points to the :macro:`NGHTTP2_VERSION` string (since age ==1)
pub version_str: *const ::std::os::raw::c_char,
/// points to the :macro:`NGHTTP2_PROTO_VERSION_ID` string this
/// instance implements (since age ==1)
pub proto_str: *const ::std::os::raw::c_char,
}
/// Invalid argument passed.
pub const NGHTTP2_ERR_INVALID_ARGUMENT: nghttp2_error = -501;
/// Out of buffer space.
pub const NGHTTP2_ERR_BUFFER_ERROR: nghttp2_error = -502;
/// The specified protocol version is not supported.
pub const NGHTTP2_ERR_UNSUPPORTED_VERSION: nghttp2_error = -503;
/// Used as a return value from :type:`nghttp2_send_callback`,
/// :type:`nghttp2_recv_callback` and
/// :type:`nghttp2_send_data_callback` to indicate that the operation
/// would block.
pub const NGHTTP2_ERR_WOULDBLOCK: nghttp2_error = -504;
/// General protocol error
pub const NGHTTP2_ERR_PROTO: nghttp2_error = -505;
/// The frame is invalid.
pub const NGHTTP2_ERR_INVALID_FRAME: nghttp2_error = -506;
/// The peer performed a shutdown on the connection.
pub const NGHTTP2_ERR_EOF: nghttp2_error = -507;
/// Used as a return value from
/// :func:`nghttp2_data_source_read_callback` to indicate that data
/// transfer is postponed. See
/// :func:`nghttp2_data_source_read_callback` for details.
pub const NGHTTP2_ERR_DEFERRED: nghttp2_error = -508;
/// Stream ID has reached the maximum value. Therefore no stream ID
/// is available.
pub const NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE: nghttp2_error = -509;
/// The stream is already closed; or the stream ID is invalid.
pub const NGHTTP2_ERR_STREAM_CLOSED: nghttp2_error = -510;
/// RST_STREAM has been added to the outbound queue. The stream is
/// in closing state.
pub const NGHTTP2_ERR_STREAM_CLOSING: nghttp2_error = -511;
/// The transmission is not allowed for this stream (e.g., a frame
/// with END_STREAM flag set has already sent).
pub const NGHTTP2_ERR_STREAM_SHUT_WR: nghttp2_error = -512;
/// The stream ID is invalid.
pub const NGHTTP2_ERR_INVALID_STREAM_ID: nghttp2_error = -513;
/// The state of the stream is not valid (e.g., DATA cannot be sent
/// to the stream if response HEADERS has not been sent).
pub const NGHTTP2_ERR_INVALID_STREAM_STATE: nghttp2_error = -514;
/// Another DATA frame has already been deferred.
pub const NGHTTP2_ERR_DEFERRED_DATA_EXIST: nghttp2_error = -515;
/// Starting new stream is not allowed (e.g., GOAWAY has been sent
/// and/or received).
pub const NGHTTP2_ERR_START_STREAM_NOT_ALLOWED: nghttp2_error = -516;
/// GOAWAY has already been sent.
pub const NGHTTP2_ERR_GOAWAY_ALREADY_SENT: nghttp2_error = -517;
/// The received frame contains the invalid header block (e.g., There
/// are duplicate header names; or the header names are not encoded
/// in US-ASCII character set and not lower cased; or the header name
/// is zero-length string; or the header value contains multiple
/// in-sequence NUL bytes).
pub const NGHTTP2_ERR_INVALID_HEADER_BLOCK: nghttp2_error = -518;
/// Indicates that the context is not suitable to perform the
/// requested operation.
pub const NGHTTP2_ERR_INVALID_STATE: nghttp2_error = -519;
/// The user callback function failed due to the temporal error.
pub const NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE: nghttp2_error = -521;
/// The length of the frame is invalid, either too large or too small.
pub const NGHTTP2_ERR_FRAME_SIZE_ERROR: nghttp2_error = -522;
/// Header block inflate/deflate error.
pub const NGHTTP2_ERR_HEADER_COMP: nghttp2_error = -523;
/// Flow control error
pub const NGHTTP2_ERR_FLOW_CONTROL: nghttp2_error = -524;
/// Insufficient buffer size given to function.
pub const NGHTTP2_ERR_INSUFF_BUFSIZE: nghttp2_error = -525;
/// Callback was paused by the application
pub const NGHTTP2_ERR_PAUSE: nghttp2_error = -526;
/// There are too many in-flight SETTING frame and no more
/// transmission of SETTINGS is allowed.
pub const NGHTTP2_ERR_TOO_MANY_INFLIGHT_SETTINGS: nghttp2_error = -527;
/// The server push is disabled.
pub const NGHTTP2_ERR_PUSH_DISABLED: nghttp2_error = -528;
/// DATA or HEADERS frame for a given stream has been already
/// submitted and has not been fully processed yet. Application
/// should wait for the transmission of the previously submitted
/// frame before submitting another.
pub const NGHTTP2_ERR_DATA_EXIST: nghttp2_error = -529;
/// The current session is closing due to a connection error or
/// `nghttp2_session_terminate_session()` is called.
pub const NGHTTP2_ERR_SESSION_CLOSING: nghttp2_error = -530;
/// Invalid HTTP header field was received and stream is going to be
/// closed.
pub const NGHTTP2_ERR_HTTP_HEADER: nghttp2_error = -531;
/// Violation in HTTP messaging rule.
pub const NGHTTP2_ERR_HTTP_MESSAGING: nghttp2_error = -532;
/// Stream was refused.
pub const NGHTTP2_ERR_REFUSED_STREAM: nghttp2_error = -533;
/// Unexpected internal error, but recovered.
pub const NGHTTP2_ERR_INTERNAL: nghttp2_error = -534;
/// Indicates that a processing was canceled.
pub const NGHTTP2_ERR_CANCEL: nghttp2_error = -535;
/// When a local endpoint expects to receive SETTINGS frame, it
/// receives an other type of frame.
pub const NGHTTP2_ERR_SETTINGS_EXPECTED: nghttp2_error = -536;
/// The errors < :enum:`NGHTTP2_ERR_FATAL` mean that the library is
/// under unexpected condition and processing was terminated (e.g.,
/// out of memory). If application receives this error code, it must
/// stop using that :type:`nghttp2_session` object and only allowed
/// operation for that object is deallocate it using
/// `nghttp2_session_del()`.
pub const NGHTTP2_ERR_FATAL: nghttp2_error = -900;
/// Out of memory. This is a fatal error.
pub const NGHTTP2_ERR_NOMEM: nghttp2_error = -901;
/// The user callback function failed. This is a fatal error.
pub const NGHTTP2_ERR_CALLBACK_FAILURE: nghttp2_error = -902;
/// Invalid client magic (see :macro:`NGHTTP2_CLIENT_MAGIC`) was
/// received and further processing is not possible.
pub const NGHTTP2_ERR_BAD_CLIENT_MAGIC: nghttp2_error = -903;
/// Possible flooding by peer was detected in this HTTP/2 session.
/// Flooding is measured by how many PING and SETTINGS frames with
/// ACK flag set are queued for transmission. These frames are
/// response for the peer initiated frames, and peer can cause memory
/// exhaustion on server side to send these frames forever and does
/// not read network.
pub const NGHTTP2_ERR_FLOODED: nghttp2_error = -904;
/// @enum
///
/// Error codes used in this library. The code range is [-999, -500],
/// inclusive. The following values are defined:
pub type nghttp2_error = i32;
/// @struct
///
/// The object representing single contiguous buffer.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_vec {
/// The pointer to the buffer.
pub base: *mut u8,
/// The length of the buffer.
pub len: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_rcbuf {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Increments the reference count of |rcbuf| by 1.
pub fn nghttp2_rcbuf_incref(rcbuf: *mut nghttp2_rcbuf);
}
extern "C" {
/// @function
///
/// Decrements the reference count of |rcbuf| by 1. If the reference
/// count becomes zero, the object pointed by |rcbuf| will be freed.
/// In this case, application must not use |rcbuf| again.
pub fn nghttp2_rcbuf_decref(rcbuf: *mut nghttp2_rcbuf);
}
extern "C" {
/// @function
///
/// Returns the underlying buffer managed by |rcbuf|.
pub fn nghttp2_rcbuf_get_buf(rcbuf: *mut nghttp2_rcbuf) -> nghttp2_vec;
}
extern "C" {
/// @function
///
/// Returns nonzero if the underlying buffer is statically allocated,
/// and 0 otherwise. This can be useful for language bindings that wish
/// to avoid creating duplicate strings for these buffers.
pub fn nghttp2_rcbuf_is_static(rcbuf: *const nghttp2_rcbuf) -> ::std::os::raw::c_int;
}
/// No flag set.
pub const NGHTTP2_NV_FLAG_NONE: nghttp2_nv_flag = 0;
/// Indicates that this name/value pair must not be indexed ("Literal
/// Header Field never Indexed" representation must be used in HPACK
/// encoding). Other implementation calls this bit as "sensitive".
pub const NGHTTP2_NV_FLAG_NO_INDEX: nghttp2_nv_flag = 1;
/// This flag is set solely by application. If this flag is set, the
/// library does not make a copy of header field name. This could
/// improve performance.
pub const NGHTTP2_NV_FLAG_NO_COPY_NAME: nghttp2_nv_flag = 2;
/// This flag is set solely by application. If this flag is set, the
/// library does not make a copy of header field value. This could
/// improve performance.
pub const NGHTTP2_NV_FLAG_NO_COPY_VALUE: nghttp2_nv_flag = 4;
/// @enum
///
/// The flags for header field name/value pair.
pub type nghttp2_nv_flag = u32;
/// @struct
///
/// The name/value pair, which mainly used to represent header fields.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_nv {
/// The |name| byte string. If this struct is presented from library
/// (e.g., :type:`nghttp2_on_frame_recv_callback`), |name| is
/// guaranteed to be NULL-terminated. For some callbacks
/// (:type:`nghttp2_before_frame_send_callback`,
/// :type:`nghttp2_on_frame_send_callback`, and
/// :type:`nghttp2_on_frame_not_send_callback`), it may not be
/// NULL-terminated if header field is passed from application with
/// the flag :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`). When application
/// is constructing this struct, |name| is not required to be
/// NULL-terminated.
pub name: *mut u8,
/// The |value| byte string. If this struct is presented from
/// library (e.g., :type:`nghttp2_on_frame_recv_callback`), |value|
/// is guaranteed to be NULL-terminated. For some callbacks
/// (:type:`nghttp2_before_frame_send_callback`,
/// :type:`nghttp2_on_frame_send_callback`, and
/// :type:`nghttp2_on_frame_not_send_callback`), it may not be
/// NULL-terminated if header field is passed from application with
/// the flag :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE`). When
/// application is constructing this struct, |value| is not required
/// to be NULL-terminated.
pub value: *mut u8,
/// The length of the |name|, excluding terminating NULL.
pub namelen: usize,
/// The length of the |value|, excluding terminating NULL.
pub valuelen: usize,
/// Bitwise OR of one or more of :type:`nghttp2_nv_flag`.
pub flags: u8,
}
/// The DATA frame.
pub const NGHTTP2_DATA: nghttp2_frame_type = 0;
/// The HEADERS frame.
pub const NGHTTP2_HEADERS: nghttp2_frame_type = 1;
/// The PRIORITY frame.
pub const NGHTTP2_PRIORITY: nghttp2_frame_type = 2;
/// The RST_STREAM frame.
pub const NGHTTP2_RST_STREAM: nghttp2_frame_type = 3;
/// The SETTINGS frame.
pub const NGHTTP2_SETTINGS: nghttp2_frame_type = 4;
/// The PUSH_PROMISE frame.
pub const NGHTTP2_PUSH_PROMISE: nghttp2_frame_type = 5;
/// The PING frame.
pub const NGHTTP2_PING: nghttp2_frame_type = 6;
/// The GOAWAY frame.
pub const NGHTTP2_GOAWAY: nghttp2_frame_type = 7;
/// The WINDOW_UPDATE frame.
pub const NGHTTP2_WINDOW_UPDATE: nghttp2_frame_type = 8;
/// The CONTINUATION frame. This frame type won't be passed to any
/// callbacks because the library processes this frame type and its
/// preceding HEADERS/PUSH_PROMISE as a single frame.
pub const NGHTTP2_CONTINUATION: nghttp2_frame_type = 9;
/// The ALTSVC frame, which is defined in `RFC 7383
/// <https://tools.ietf.org/html/rfc7838#section-4>`_.
pub const NGHTTP2_ALTSVC: nghttp2_frame_type = 10;
/// The ORIGIN frame, which is defined by `RFC 8336
/// <https://tools.ietf.org/html/rfc8336>`_.
pub const NGHTTP2_ORIGIN: nghttp2_frame_type = 12;
/// @enum
///
/// The frame types in HTTP/2 specification.
pub type nghttp2_frame_type = u32;
/// No flag set.
pub const NGHTTP2_FLAG_NONE: nghttp2_flag = 0;
/// The END_STREAM flag.
pub const NGHTTP2_FLAG_END_STREAM: nghttp2_flag = 1;
/// The END_HEADERS flag.
pub const NGHTTP2_FLAG_END_HEADERS: nghttp2_flag = 4;
/// The ACK flag.
pub const NGHTTP2_FLAG_ACK: nghttp2_flag = 1;
/// The PADDED flag.
pub const NGHTTP2_FLAG_PADDED: nghttp2_flag = 8;
/// The PRIORITY flag.
pub const NGHTTP2_FLAG_PRIORITY: nghttp2_flag = 32;
/// @enum
///
/// The flags for HTTP/2 frames. This enum defines all flags for all
/// frames.
pub type nghttp2_flag = u32;
/// SETTINGS_HEADER_TABLE_SIZE
pub const NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: nghttp2_settings_id = 1;
/// SETTINGS_ENABLE_PUSH
pub const NGHTTP2_SETTINGS_ENABLE_PUSH: nghttp2_settings_id = 2;
/// SETTINGS_MAX_CONCURRENT_STREAMS
pub const NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: nghttp2_settings_id = 3;
/// SETTINGS_INITIAL_WINDOW_SIZE
pub const NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: nghttp2_settings_id = 4;
/// SETTINGS_MAX_FRAME_SIZE
pub const NGHTTP2_SETTINGS_MAX_FRAME_SIZE: nghttp2_settings_id = 5;
/// SETTINGS_MAX_HEADER_LIST_SIZE
pub const NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: nghttp2_settings_id = 6;
/// @enum
/// The SETTINGS ID.
pub type nghttp2_settings_id = u32;
/// No errors.
pub const NGHTTP2_NO_ERROR: nghttp2_error_code = 0;
/// PROTOCOL_ERROR
pub const NGHTTP2_PROTOCOL_ERROR: nghttp2_error_code = 1;
/// INTERNAL_ERROR
pub const NGHTTP2_INTERNAL_ERROR: nghttp2_error_code = 2;
/// FLOW_CONTROL_ERROR
pub const NGHTTP2_FLOW_CONTROL_ERROR: nghttp2_error_code = 3;
/// SETTINGS_TIMEOUT
pub const NGHTTP2_SETTINGS_TIMEOUT: nghttp2_error_code = 4;
/// STREAM_CLOSED
pub const NGHTTP2_STREAM_CLOSED: nghttp2_error_code = 5;
/// FRAME_SIZE_ERROR
pub const NGHTTP2_FRAME_SIZE_ERROR: nghttp2_error_code = 6;
/// REFUSED_STREAM
pub const NGHTTP2_REFUSED_STREAM: nghttp2_error_code = 7;
/// CANCEL
pub const NGHTTP2_CANCEL: nghttp2_error_code = 8;
/// COMPRESSION_ERROR
pub const NGHTTP2_COMPRESSION_ERROR: nghttp2_error_code = 9;
/// CONNECT_ERROR
pub const NGHTTP2_CONNECT_ERROR: nghttp2_error_code = 10;
/// ENHANCE_YOUR_CALM
pub const NGHTTP2_ENHANCE_YOUR_CALM: nghttp2_error_code = 11;
/// INADEQUATE_SECURITY
pub const NGHTTP2_INADEQUATE_SECURITY: nghttp2_error_code = 12;
/// HTTP_1_1_REQUIRED
pub const NGHTTP2_HTTP_1_1_REQUIRED: nghttp2_error_code = 13;
/// @enum
/// The status codes for the RST_STREAM and GOAWAY frames.
pub type nghttp2_error_code = u32;
/// @struct
/// The frame header.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_frame_hd {
/// The length field of this frame, excluding frame header.
pub length: usize,
/// The stream identifier (aka, stream ID)
pub stream_id: i32,
/// The type of this frame. See `nghttp2_frame_type`.
pub type_: u8,
/// The flags.
pub flags: u8,
/// Reserved bit in frame header. Currently, this is always set to 0
/// and application should not expect something useful in here.
pub reserved: u8,
}
/// @union
///
/// This union represents the some kind of data source passed to
/// :type:`nghttp2_data_source_read_callback`.
#[repr(C)]
#[derive(Copy, Clone)]
pub union nghttp2_data_source {
/// The integer field, suitable for a file descriptor.
pub fd: ::std::os::raw::c_int,
/// The pointer to an arbitrary object.
pub ptr: *mut ::std::os::raw::c_void,
_bindgen_union_align: u64,
}
/// No flag set.
pub const NGHTTP2_DATA_FLAG_NONE: nghttp2_data_flag = 0;
/// Indicates EOF was sensed.
pub const NGHTTP2_DATA_FLAG_EOF: nghttp2_data_flag = 1;
/// Indicates that END_STREAM flag must not be set even if
/// NGHTTP2_DATA_FLAG_EOF is set. Usually this flag is used to send
/// trailer fields with `nghttp2_submit_request()` or
/// `nghttp2_submit_response()`.
pub const NGHTTP2_DATA_FLAG_NO_END_STREAM: nghttp2_data_flag = 2;
/// Indicates that application will send complete DATA frame in
/// :type:`nghttp2_send_data_callback`.
pub const NGHTTP2_DATA_FLAG_NO_COPY: nghttp2_data_flag = 4;
/// @enum
///
/// The flags used to set in |data_flags| output parameter in
/// :type:`nghttp2_data_source_read_callback`.
pub type nghttp2_data_flag = u32;
/// @functypedef
///
/// Callback function invoked when the library wants to read data from
/// the |source|. The read data is sent in the stream |stream_id|.
/// The implementation of this function must read at most |length|
/// bytes of data from |source| (or possibly other places) and store
/// them in |buf| and return number of data stored in |buf|. If EOF is
/// reached, set :enum:`NGHTTP2_DATA_FLAG_EOF` flag in |*data_flags|.
///
/// Sometime it is desirable to avoid copying data into |buf| and let
/// application to send data directly. To achieve this, set
/// :enum:`NGHTTP2_DATA_FLAG_NO_COPY` to |*data_flags| (and possibly
/// other flags, just like when we do copy), and return the number of
/// bytes to send without copying data into |buf|. The library, seeing
/// :enum:`NGHTTP2_DATA_FLAG_NO_COPY`, will invoke
/// :type:`nghttp2_send_data_callback`. The application must send
/// complete DATA frame in that callback.
///
/// If this callback is set by `nghttp2_submit_request()`,
/// `nghttp2_submit_response()` or `nghttp2_submit_headers()` and
/// `nghttp2_submit_data()` with flag parameter
/// :enum:`NGHTTP2_FLAG_END_STREAM` set, and
/// :enum:`NGHTTP2_DATA_FLAG_EOF` flag is set to |*data_flags|, DATA
/// frame will have END_STREAM flag set. Usually, this is expected
/// behaviour and all are fine. One exception is send trailer fields.
/// You cannot send trailer fields after sending frame with END_STREAM
/// set. To avoid this problem, one can set
/// :enum:`NGHTTP2_DATA_FLAG_NO_END_STREAM` along with
/// :enum:`NGHTTP2_DATA_FLAG_EOF` to signal the library not to set
/// END_STREAM in DATA frame. Then application can use
/// `nghttp2_submit_trailer()` to send trailer fields.
/// `nghttp2_submit_trailer()` can be called inside this callback.
///
/// If the application wants to postpone DATA frames (e.g.,
/// asynchronous I/O, or reading data blocks for long time), it is
/// achieved by returning :enum:`NGHTTP2_ERR_DEFERRED` without reading
/// any data in this invocation. The library removes DATA frame from
/// the outgoing queue temporarily. To move back deferred DATA frame
/// to outgoing queue, call `nghttp2_session_resume_data()`.
///
/// By default, |length| is limited to 16KiB at maximum. If peer
/// allows larger frames, application can enlarge transmission buffer
/// size. See :type:`nghttp2_data_source_read_length_callback` for
/// more details.
///
/// If the application just wants to return from
/// `nghttp2_session_send()` or `nghttp2_session_mem_send()` without
/// sending anything, return :enum:`NGHTTP2_ERR_PAUSE`.
///
/// In case of error, there are 2 choices. Returning
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will close the stream
/// by issuing RST_STREAM with :enum:`NGHTTP2_INTERNAL_ERROR`. If a
/// different error code is desirable, use
/// `nghttp2_submit_rst_stream()` with a desired error code and then
/// return :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. Returning
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` will signal the entire session
/// failure.
pub type nghttp2_data_source_read_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
stream_id: i32,
buf: *mut u8,
length: usize,
data_flags: *mut u32,
source: *mut nghttp2_data_source,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @struct
///
/// This struct represents the data source and the way to read a chunk
/// of data from it.
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nghttp2_data_provider {
/// The data source.
pub source: nghttp2_data_source,
/// The callback function to read a chunk of data from the |source|.
pub read_callback: nghttp2_data_source_read_callback,
}
/// @struct
///
/// The DATA frame. The received data is delivered via
/// :type:`nghttp2_on_data_chunk_recv_callback`.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_data {
pub hd: nghttp2_frame_hd,
/// The length of the padding in this frame. This includes PAD_HIGH
/// and PAD_LOW.
pub padlen: usize,
}
/// The HEADERS frame is opening new stream, which is analogous to
/// SYN_STREAM in SPDY.
pub const NGHTTP2_HCAT_REQUEST: nghttp2_headers_category = 0;
/// The HEADERS frame is the first response headers, which is
/// analogous to SYN_REPLY in SPDY.
pub const NGHTTP2_HCAT_RESPONSE: nghttp2_headers_category = 1;
/// The HEADERS frame is the first headers sent against reserved
/// stream.
pub const NGHTTP2_HCAT_PUSH_RESPONSE: nghttp2_headers_category = 2;
/// The HEADERS frame which does not apply for the above categories,
/// which is analogous to HEADERS in SPDY. If non-final response
/// (e.g., status 1xx) is used, final response HEADERS frame will be
/// categorized here.
pub const NGHTTP2_HCAT_HEADERS: nghttp2_headers_category = 3;
/// @enum
///
/// The category of HEADERS, which indicates the role of the frame. In
/// HTTP/2 spec, request, response, push response and other arbitrary
/// headers (e.g., trailer fields) are all called just HEADERS. To
/// give the application the role of incoming HEADERS frame, we define
/// several categories.
pub type nghttp2_headers_category = u32;
/// @struct
///
/// The structure to specify stream dependency.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_priority_spec {
/// The stream ID of the stream to depend on. Specifying 0 makes
/// stream not depend any other stream.
pub stream_id: i32,
/// The weight of this dependency.
pub weight: i32,
/// nonzero means exclusive dependency
pub exclusive: u8,
}
/// @struct
///
/// The HEADERS frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_headers {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The length of the padding in this frame. This includes PAD_HIGH
/// and PAD_LOW.
pub padlen: usize,
/// The priority specification
pub pri_spec: nghttp2_priority_spec,
/// The name/value pairs.
pub nva: *mut nghttp2_nv,
/// The number of name/value pairs in |nva|.
pub nvlen: usize,
/// The category of this HEADERS frame.
pub cat: nghttp2_headers_category,
}
/// @struct
///
/// The PRIORITY frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_priority {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The priority specification.
pub pri_spec: nghttp2_priority_spec,
}
/// @struct
///
/// The RST_STREAM frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_rst_stream {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The error code. See :type:`nghttp2_error_code`.
pub error_code: u32,
}
/// @struct
///
/// The SETTINGS ID/Value pair. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_settings_entry {
/// The SETTINGS ID. See :type:`nghttp2_settings_id`.
pub settings_id: i32,
/// The value of this entry.
pub value: u32,
}
/// @struct
///
/// The SETTINGS frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_settings {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The number of SETTINGS ID/Value pairs in |iv|.
pub niv: usize,
/// The pointer to the array of SETTINGS ID/Value pair.
pub iv: *mut nghttp2_settings_entry,
}
/// @struct
///
/// The PUSH_PROMISE frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_push_promise {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The length of the padding in this frame. This includes PAD_HIGH
/// and PAD_LOW.
pub padlen: usize,
/// The name/value pairs.
pub nva: *mut nghttp2_nv,
/// The number of name/value pairs in |nva|.
pub nvlen: usize,
/// The promised stream ID
pub promised_stream_id: i32,
/// Reserved bit. Currently this is always set to 0 and application
/// should not expect something useful in here.
pub reserved: u8,
}
/// @struct
///
/// The PING frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_ping {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The opaque data
pub opaque_data: [u8; 8usize],
}
/// @struct
///
/// The GOAWAY frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_goaway {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The last stream stream ID.
pub last_stream_id: i32,
/// The error code. See :type:`nghttp2_error_code`.
pub error_code: u32,
/// The additional debug data
pub opaque_data: *mut u8,
/// The length of |opaque_data| member.
pub opaque_data_len: usize,
/// Reserved bit. Currently this is always set to 0 and application
/// should not expect something useful in here.
pub reserved: u8,
}
/// @struct
///
/// The WINDOW_UPDATE frame. It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_window_update {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The window size increment.
pub window_size_increment: i32,
/// Reserved bit. Currently this is always set to 0 and application
/// should not expect something useful in here.
pub reserved: u8,
}
/// @struct
///
/// The extension frame. It has following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_extension {
/// The frame header.
pub hd: nghttp2_frame_hd,
/// The pointer to extension payload. The exact pointer type is
/// determined by hd.type.
///
/// Currently, no extension is supported. This is a place holder for
/// the future extensions.
pub payload: *mut ::std::os::raw::c_void,
}
/// @union
///
/// This union includes all frames to pass them to various function
/// calls as nghttp2_frame type. The CONTINUATION frame is omitted
/// from here because the library deals with it internally.
#[repr(C)]
#[derive(Copy, Clone)]
pub union nghttp2_frame {
/// The frame header, which is convenient to inspect frame header.
pub hd: nghttp2_frame_hd,
/// The DATA frame.
pub data: nghttp2_data,
/// The HEADERS frame.
pub headers: nghttp2_headers,
/// The PRIORITY frame.
pub priority: nghttp2_priority,
/// The RST_STREAM frame.
pub rst_stream: nghttp2_rst_stream,
/// The SETTINGS frame.
pub settings: nghttp2_settings,
/// The PUSH_PROMISE frame.
pub push_promise: nghttp2_push_promise,
/// The PING frame.
pub ping: nghttp2_ping,
/// The GOAWAY frame.
pub goaway: nghttp2_goaway,
/// The WINDOW_UPDATE frame.
pub window_update: nghttp2_window_update,
/// The extension frame.
pub ext: nghttp2_extension,
_bindgen_union_align: [u64; 8usize],
}
/// @functypedef
///
/// Callback function invoked when |session| wants to send data to the
/// remote peer. The implementation of this function must send at most
/// |length| bytes of data stored in |data|. The |flags| is currently
/// not used and always 0. It must return the number of bytes sent if
/// it succeeds. If it cannot send any single byte without blocking,
/// it must return :enum:`NGHTTP2_ERR_WOULDBLOCK`. For other errors,
/// it must return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. The
/// |user_data| pointer is the third argument passed in to the call to
/// `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.
///
/// This callback is required if the application uses
/// `nghttp2_session_send()` to send data to the remote endpoint. If
/// the application uses solely `nghttp2_session_mem_send()` instead,
/// this callback function is unnecessary.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_send_callback()`.
///
/// .. note::
///
/// The |length| may be very small. If that is the case, and
/// application disables Nagle algorithm (``TCP_NODELAY``), then just
/// writing |data| to the network stack leads to very small packet,
/// and it is very inefficient. An application should be responsible
/// to buffer up small chunks of data as necessary to avoid this
/// situation.
pub type nghttp2_send_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
data: *const u8,
length: usize,
flags: ::std::os::raw::c_int,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @functypedef
///
/// Callback function invoked when :enum:`NGHTTP2_DATA_FLAG_NO_COPY` is
/// used in :type:`nghttp2_data_source_read_callback` to send complete
/// DATA frame.
///
/// The |frame| is a DATA frame to send. The |framehd| is the
/// serialized frame header (9 bytes). The |length| is the length of
/// application data to send (this does not include padding). The
/// |source| is the same pointer passed to
/// :type:`nghttp2_data_source_read_callback`.
///
/// The application first must send frame header |framehd| of length 9
/// bytes. If ``frame->data.padlen > 0``, send 1 byte of value
/// ``frame->data.padlen - 1``. Then send exactly |length| bytes of
/// application data. Finally, if ``frame->data.padlen > 1``, send
/// ``frame->data.padlen - 1`` bytes of zero as padding.
///
/// The application has to send complete DATA frame in this callback.
/// If all data were written successfully, return 0.
///
/// If it cannot send any data at all, just return
/// :enum:`NGHTTP2_ERR_WOULDBLOCK`; the library will call this callback
/// with the same parameters later (It is recommended to send complete
/// DATA frame at once in this function to deal with error; if partial
/// frame data has already sent, it is impossible to send another data
/// in that state, and all we can do is tear down connection). When
/// data is fully processed, but application wants to make
/// `nghttp2_session_mem_send()` or `nghttp2_session_send()` return
/// immediately without processing next frames, return
/// :enum:`NGHTTP2_ERR_PAUSE`. If application decided to reset this
/// stream, return :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`, then
/// the library will send RST_STREAM with INTERNAL_ERROR as error code.
/// The application can also return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`, which will result in
/// connection closure. Returning any other value is treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` is returned.
pub type nghttp2_send_data_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *mut nghttp2_frame,
framehd: *const u8,
length: usize,
source: *mut nghttp2_data_source,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when |session| wants to receive data from
/// the remote peer. The implementation of this function must read at
/// most |length| bytes of data and store it in |buf|. The |flags| is
/// currently not used and always 0. It must return the number of
/// bytes written in |buf| if it succeeds. If it cannot read any
/// single byte without blocking, it must return
/// :enum:`NGHTTP2_ERR_WOULDBLOCK`. If it gets EOF before it reads any
/// single byte, it must return :enum:`NGHTTP2_ERR_EOF`. For other
/// errors, it must return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
/// Returning 0 is treated as :enum:`NGHTTP2_ERR_WOULDBLOCK`. The
/// |user_data| pointer is the third argument passed in to the call to
/// `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.
///
/// This callback is required if the application uses
/// `nghttp2_session_recv()` to receive data from the remote endpoint.
/// If the application uses solely `nghttp2_session_mem_recv()`
/// instead, this callback function is unnecessary.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_recv_callback()`.
pub type nghttp2_recv_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
buf: *mut u8,
length: usize,
flags: ::std::os::raw::c_int,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @functypedef
///
/// Callback function invoked by `nghttp2_session_recv()` and
/// `nghttp2_session_mem_recv()` when a frame is received. The
/// |user_data| pointer is the third argument passed in to the call to
/// `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.
///
/// If frame is HEADERS or PUSH_PROMISE, the ``nva`` and ``nvlen``
/// member of their data structure are always ``NULL`` and 0
/// respectively. The header name/value pairs are emitted via
/// :type:`nghttp2_on_header_callback`.
///
/// For HEADERS, PUSH_PROMISE and DATA frames, this callback may be
/// called after stream is closed (see
/// :type:`nghttp2_on_stream_close_callback`). The application should
/// check that stream is still alive using its own stream management or
/// :func:`nghttp2_session_get_stream_user_data()`.
///
/// Only HEADERS and DATA frame can signal the end of incoming data.
/// If ``frame->hd.flags & NGHTTP2_FLAG_END_STREAM`` is nonzero, the
/// |frame| is the last frame from the remote peer in this stream.
///
/// This callback won't be called for CONTINUATION frames.
/// HEADERS/PUSH_PROMISE + CONTINUATIONs are treated as single frame.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero value is returned, it is treated as fatal error and
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_frame_recv_callback()`.
pub type nghttp2_on_frame_recv_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked by `nghttp2_session_recv()` and
/// `nghttp2_session_mem_recv()` when an invalid non-DATA frame is
/// received. The error is indicated by the |lib_error_code|, which is
/// one of the values defined in :type:`nghttp2_error`. When this
/// callback function is invoked, the library automatically submits
/// either RST_STREAM or GOAWAY frame. The |user_data| pointer is the
/// third argument passed in to the call to
/// `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.
///
/// If frame is HEADERS or PUSH_PROMISE, the ``nva`` and ``nvlen``
/// member of their data structure are always ``NULL`` and 0
/// respectively.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero is returned, it is treated as fatal error and
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_invalid_frame_recv_callback()`.
pub type nghttp2_on_invalid_frame_recv_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
lib_error_code: ::std::os::raw::c_int,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when a chunk of data in DATA frame is
/// received. The |stream_id| is the stream ID this DATA frame belongs
/// to. The |flags| is the flags of DATA frame which this data chunk
/// is contained. ``(flags & NGHTTP2_FLAG_END_STREAM) != 0`` does not
/// necessarily mean this chunk of data is the last one in the stream.
/// You should use :type:`nghttp2_on_frame_recv_callback` to know all
/// data frames are received. The |user_data| pointer is the third
/// argument passed in to the call to `nghttp2_session_client_new()` or
/// `nghttp2_session_server_new()`.
///
/// If the application uses `nghttp2_session_mem_recv()`, it can return
/// :enum:`NGHTTP2_ERR_PAUSE` to make `nghttp2_session_mem_recv()`
/// return without processing further input bytes. The memory by
/// pointed by the |data| is retained until
/// `nghttp2_session_mem_recv()` or `nghttp2_session_recv()` is called.
/// The application must retain the input bytes which was used to
/// produce the |data| parameter, because it may refer to the memory
/// region included in the input bytes.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero is returned, it is treated as fatal error, and
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_data_chunk_recv_callback()`.
pub type nghttp2_on_data_chunk_recv_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
data: *const u8,
len: usize,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked just before the non-DATA frame |frame| is
/// sent. The |user_data| pointer is the third argument passed in to
/// the call to `nghttp2_session_client_new()` or
/// `nghttp2_session_server_new()`.
///
/// The implementation of this function must return 0 if it succeeds.
/// It can also return :enum:`NGHTTP2_ERR_CANCEL` to cancel the
/// transmission of the given frame.
///
/// If there is a fatal error while executing this callback, the
/// implementation should return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`,
/// which makes `nghttp2_session_send()` and
/// `nghttp2_session_mem_send()` functions immediately return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// If the other value is returned, it is treated as if
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` is returned. But the
/// implementation should not rely on this since the library may define
/// new return value to extend its capability.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_before_frame_send_callback()`.
pub type nghttp2_before_frame_send_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked after the frame |frame| is sent. The
/// |user_data| pointer is the third argument passed in to the call to
/// `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero is returned, it is treated as fatal error and
/// `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_frame_send_callback()`.
pub type nghttp2_on_frame_send_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked after the non-DATA frame |frame| is not
/// sent because of the error. The error is indicated by the
/// |lib_error_code|, which is one of the values defined in
/// :type:`nghttp2_error`. The |user_data| pointer is the third
/// argument passed in to the call to `nghttp2_session_client_new()` or
/// `nghttp2_session_server_new()`.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero is returned, it is treated as fatal error and
/// `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// `nghttp2_session_get_stream_user_data()` can be used to get
/// associated data.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_frame_not_send_callback()`.
pub type nghttp2_on_frame_not_send_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
lib_error_code: ::std::os::raw::c_int,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when the stream |stream_id| is closed.
/// The reason of closure is indicated by the |error_code|. The
/// |error_code| is usually one of :enum:`nghttp2_error_code`, but that
/// is not guaranteed. The stream_user_data, which was specified in
/// `nghttp2_submit_request()` or `nghttp2_submit_headers()`, is still
/// available in this function. The |user_data| pointer is the third
/// argument passed in to the call to `nghttp2_session_client_new()` or
/// `nghttp2_session_server_new()`.
///
/// This function is also called for a stream in reserved state.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero is returned, it is treated as fatal error and
/// `nghttp2_session_recv()`, `nghttp2_session_mem_recv()`,
/// `nghttp2_session_send()`, and `nghttp2_session_mem_send()`
/// functions immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_stream_close_callback()`.
pub type nghttp2_on_stream_close_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
stream_id: i32,
error_code: u32,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when the reception of header block in
/// HEADERS or PUSH_PROMISE is started. Each header name/value pair
/// will be emitted by :type:`nghttp2_on_header_callback`.
///
/// The ``frame->hd.flags`` may not have
/// :enum:`NGHTTP2_FLAG_END_HEADERS` flag set, which indicates that one
/// or more CONTINUATION frames are involved. But the application does
/// not need to care about that because the header name/value pairs are
/// emitted transparently regardless of CONTINUATION frames.
///
/// The server applications probably create an object to store
/// information about new stream if ``frame->hd.type ==
/// NGHTTP2_HEADERS`` and ``frame->headers.cat ==
/// NGHTTP2_HCAT_REQUEST``. If |session| is configured as server side,
/// ``frame->headers.cat`` is either ``NGHTTP2_HCAT_REQUEST``
/// containing request headers or ``NGHTTP2_HCAT_HEADERS`` containing
/// trailer fields and never get PUSH_PROMISE in this callback.
///
/// For the client applications, ``frame->hd.type`` is either
/// ``NGHTTP2_HEADERS`` or ``NGHTTP2_PUSH_PROMISE``. In case of
/// ``NGHTTP2_HEADERS``, ``frame->headers.cat ==
/// NGHTTP2_HCAT_RESPONSE`` means that it is the first response
/// headers, but it may be non-final response which is indicated by 1xx
/// status code. In this case, there may be zero or more HEADERS frame
/// with ``frame->headers.cat == NGHTTP2_HCAT_HEADERS`` which has
/// non-final response code and finally client gets exactly one HEADERS
/// frame with ``frame->headers.cat == NGHTTP2_HCAT_HEADERS``
/// containing final response headers (non-1xx status code). The
/// trailer fields also has ``frame->headers.cat ==
/// NGHTTP2_HCAT_HEADERS`` which does not contain any status code.
///
/// Returning :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will close
/// the stream (promised stream if frame is PUSH_PROMISE) by issuing
/// RST_STREAM with :enum:`NGHTTP2_INTERNAL_ERROR`. In this case,
/// :type:`nghttp2_on_header_callback` and
/// :type:`nghttp2_on_frame_recv_callback` will not be invoked. If a
/// different error code is desirable, use
/// `nghttp2_submit_rst_stream()` with a desired error code and then
/// return :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. Again, use
/// ``frame->push_promise.promised_stream_id`` as stream_id parameter
/// in `nghttp2_submit_rst_stream()` if frame is PUSH_PROMISE.
///
/// The implementation of this function must return 0 if it succeeds.
/// It can return :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` to
/// reset the stream (promised stream if frame is PUSH_PROMISE). For
/// critical errors, it must return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If the other value is
/// returned, it is treated as if :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`
/// is returned. If :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` is returned,
/// `nghttp2_session_mem_recv()` function will immediately return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_begin_headers_callback()`.
pub type nghttp2_on_begin_headers_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when a header name/value pair is received
/// for the |frame|. The |name| of length |namelen| is header name.
/// The |value| of length |valuelen| is header value. The |flags| is
/// bitwise OR of one or more of :type:`nghttp2_nv_flag`.
///
/// If :enum:`NGHTTP2_NV_FLAG_NO_INDEX` is set in |flags|, the receiver
/// must not index this name/value pair when forwarding it to the next
/// hop. More specifically, "Literal Header Field never Indexed"
/// representation must be used in HPACK encoding.
///
/// When this callback is invoked, ``frame->hd.type`` is either
/// :enum:`NGHTTP2_HEADERS` or :enum:`NGHTTP2_PUSH_PROMISE`. After all
/// header name/value pairs are processed with this callback, and no
/// error has been detected, :type:`nghttp2_on_frame_recv_callback`
/// will be invoked. If there is an error in decompression,
/// :type:`nghttp2_on_frame_recv_callback` for the |frame| will not be
/// invoked.
///
/// Both |name| and |value| are guaranteed to be NULL-terminated. The
/// |namelen| and |valuelen| do not include terminal NULL. If
/// `nghttp2_option_set_no_http_messaging()` is used with nonzero
/// value, NULL character may be included in |name| or |value| before
/// terminating NULL.
///
/// Please note that unless `nghttp2_option_set_no_http_messaging()` is
/// used, nghttp2 library does perform validation against the |name|
/// and the |value| using `nghttp2_check_header_name()` and
/// `nghttp2_check_header_value()`. In addition to this, nghttp2
/// performs validation based on HTTP Messaging rule, which is briefly
/// explained in :ref:`http-messaging` section.
///
/// If the application uses `nghttp2_session_mem_recv()`, it can return
/// :enum:`NGHTTP2_ERR_PAUSE` to make `nghttp2_session_mem_recv()`
/// return without processing further input bytes. The memory pointed
/// by |frame|, |name| and |value| parameters are retained until
/// `nghttp2_session_mem_recv()` or `nghttp2_session_recv()` is called.
/// The application must retain the input bytes which was used to
/// produce these parameters, because it may refer to the memory region
/// included in the input bytes.
///
/// Returning :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will close
/// the stream (promised stream if frame is PUSH_PROMISE) by issuing
/// RST_STREAM with :enum:`NGHTTP2_INTERNAL_ERROR`. In this case,
/// :type:`nghttp2_on_header_callback` and
/// :type:`nghttp2_on_frame_recv_callback` will not be invoked. If a
/// different error code is desirable, use
/// `nghttp2_submit_rst_stream()` with a desired error code and then
/// return :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. Again, use
/// ``frame->push_promise.promised_stream_id`` as stream_id parameter
/// in `nghttp2_submit_rst_stream()` if frame is PUSH_PROMISE.
///
/// The implementation of this function must return 0 if it succeeds.
/// It may return :enum:`NGHTTP2_ERR_PAUSE` or
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. For other critical
/// failures, it must return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If
/// the other nonzero value is returned, it is treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` is returned,
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_header_callback()`.
///
/// .. warning::
///
/// Application should properly limit the total buffer size to store
/// incoming header fields. Without it, peer may send large number
/// of header fields or large header fields to cause out of memory in
/// local endpoint. Due to how HPACK works, peer can do this
/// effectively without using much memory on their own.
pub type nghttp2_on_header_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
name: *const u8,
namelen: usize,
value: *const u8,
valuelen: usize,
flags: u8,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when a header name/value pair is received
/// for the |frame|. The |name| is header name. The |value| is header
/// value. The |flags| is bitwise OR of one or more of
/// :type:`nghttp2_nv_flag`.
///
/// This callback behaves like :type:`nghttp2_on_header_callback`,
/// except that |name| and |value| are stored in reference counted
/// buffer. If application wishes to keep these references without
/// copying them, use `nghttp2_rcbuf_incref()` to increment their
/// reference count. It is the application's responsibility to call
/// `nghttp2_rcbuf_decref()` if they called `nghttp2_rcbuf_incref()` so
/// as not to leak memory. If the |session| is created by
/// `nghttp2_session_server_new3()` or `nghttp2_session_client_new3()`,
/// the function to free memory is the one belongs to the mem
/// parameter. As long as this free function alives, |name| and
/// |value| can live after |session| was destroyed.
pub type nghttp2_on_header_callback2 = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
name: *mut nghttp2_rcbuf,
value: *mut nghttp2_rcbuf,
flags: u8,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when a invalid header name/value pair is
/// received for the |frame|.
///
/// The parameter and behaviour are similar to
/// :type:`nghttp2_on_header_callback`. The difference is that this
/// callback is only invoked when a invalid header name/value pair is
/// received which is treated as stream error if this callback is not
/// set. Only invalid regular header field are passed to this
/// callback. In other words, invalid pseudo header field is not
/// passed to this callback. Also header fields which includes upper
/// cased latter are also treated as error without passing them to this
/// callback.
///
/// This callback is only considered if HTTP messaging validation is
/// turned on (which is on by default, see
/// `nghttp2_option_set_no_http_messaging()`).
///
/// With this callback, application inspects the incoming invalid
/// field, and it also can reset stream from this callback by returning
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. By default, the
/// error code is :enum:`NGHTTP2_PROTOCOL_ERROR`. To change the error
/// code, call `nghttp2_submit_rst_stream()` with the error code of
/// choice in addition to returning
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.
///
/// If 0 is returned, the header field is ignored, and the stream is
/// not reset.
pub type nghttp2_on_invalid_header_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
name: *const u8,
namelen: usize,
value: *const u8,
valuelen: usize,
flags: u8,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when a invalid header name/value pair is
/// received for the |frame|.
///
/// The parameter and behaviour are similar to
/// :type:`nghttp2_on_header_callback2`. The difference is that this
/// callback is only invoked when a invalid header name/value pair is
/// received which is silently ignored if this callback is not set.
/// Only invalid regular header field are passed to this callback. In
/// other words, invalid pseudo header field is not passed to this
/// callback. Also header fields which includes upper cased latter are
/// also treated as error without passing them to this callback.
///
/// This callback is only considered if HTTP messaging validation is
/// turned on (which is on by default, see
/// `nghttp2_option_set_no_http_messaging()`).
///
/// With this callback, application inspects the incoming invalid
/// field, and it also can reset stream from this callback by returning
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. By default, the
/// error code is :enum:`NGHTTP2_INTERNAL_ERROR`. To change the error
/// code, call `nghttp2_submit_rst_stream()` with the error code of
/// choice in addition to returning
/// :enum:`NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.
pub type nghttp2_on_invalid_header_callback2 = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
name: *mut nghttp2_rcbuf,
value: *mut nghttp2_rcbuf,
flags: u8,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when the library asks application how
/// many padding bytes are required for the transmission of the
/// |frame|. The application must choose the total length of payload
/// including padded bytes in range [frame->hd.length, max_payloadlen],
/// inclusive. Choosing number not in this range will be treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. Returning
/// ``frame->hd.length`` means no padding is added. Returning
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` will make
/// `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_select_padding_callback()`.
pub type nghttp2_select_padding_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame: *const nghttp2_frame,
max_payloadlen: usize,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @functypedef
///
/// Callback function invoked when library wants to get max length of
/// data to send data to the remote peer. The implementation of this
/// function should return a value in the following range. [1,
/// min(|session_remote_window_size|, |stream_remote_window_size|,
/// |remote_max_frame_size|)]. If a value greater than this range is
/// returned than the max allow value will be used. Returning a value
/// smaller than this range is treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. The |frame_type| is provided
/// for future extensibility and identifies the type of frame (see
/// :type:`nghttp2_frame_type`) for which to get the length for.
/// Currently supported frame types are: :enum:`NGHTTP2_DATA`.
///
/// This callback can be used to control the length in bytes for which
/// :type:`nghttp2_data_source_read_callback` is allowed to send to the
/// remote endpoint. This callback is optional. Returning
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE` will signal the entire session
/// failure.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_data_source_read_length_callback()`.
pub type nghttp2_data_source_read_length_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
frame_type: u8,
stream_id: i32,
session_remote_window_size: i32,
stream_remote_window_size: i32,
remote_max_frame_size: u32,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @functypedef
///
/// Callback function invoked when a frame header is received. The
/// |hd| points to received frame header.
///
/// Unlike :type:`nghttp2_on_frame_recv_callback`, this callback will
/// also be called when frame header of CONTINUATION frame is received.
///
/// If both :type:`nghttp2_on_begin_frame_callback` and
/// :type:`nghttp2_on_begin_headers_callback` are set and HEADERS or
/// PUSH_PROMISE is received, :type:`nghttp2_on_begin_frame_callback`
/// will be called first.
///
/// The implementation of this function must return 0 if it succeeds.
/// If nonzero value is returned, it is treated as fatal error and
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
///
/// To set this callback to :type:`nghttp2_session_callbacks`, use
/// `nghttp2_session_callbacks_set_on_begin_frame_callback()`.
pub type nghttp2_on_begin_frame_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
hd: *const nghttp2_frame_hd,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when chunk of extension frame payload is
/// received. The |hd| points to frame header. The received
/// chunk is |data| of length |len|.
///
/// The implementation of this function must return 0 if it succeeds.
///
/// To abort processing this extension frame, return
/// :enum:`NGHTTP2_ERR_CANCEL`.
///
/// If fatal error occurred, application should return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If the
/// other values are returned, currently they are treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
pub type nghttp2_on_extension_chunk_recv_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
hd: *const nghttp2_frame_hd,
data: *const u8,
len: usize,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when library asks the application to
/// unpack extension payload from its wire format. The extension
/// payload has been passed to the application using
/// :type:`nghttp2_on_extension_chunk_recv_callback`. The frame header
/// is already unpacked by the library and provided as |hd|.
///
/// To receive extension frames, the application must tell desired
/// extension frame type to the library using
/// `nghttp2_option_set_user_recv_extension_type()`.
///
/// The implementation of this function may store the pointer to the
/// created object as a result of unpacking in |*payload|, and returns
/// 0. The pointer stored in |*payload| is opaque to the library, and
/// the library does not own its pointer. |*payload| is initialized as
/// ``NULL``. The |*payload| is available as ``frame->ext.payload`` in
/// :type:`nghttp2_on_frame_recv_callback`. Therefore if application
/// can free that memory inside :type:`nghttp2_on_frame_recv_callback`
/// callback. Of course, application has a liberty not ot use
/// |*payload|, and do its own mechanism to process extension frames.
///
/// To abort processing this extension frame, return
/// :enum:`NGHTTP2_ERR_CANCEL`.
///
/// If fatal error occurred, application should return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,
/// `nghttp2_session_recv()` and `nghttp2_session_mem_recv()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If the
/// other values are returned, currently they are treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
pub type nghttp2_unpack_extension_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
payload: *mut *mut ::std::os::raw::c_void,
hd: *const nghttp2_frame_hd,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when library asks the application to pack
/// extension payload in its wire format. The frame header will be
/// packed by library. Application must pack payload only.
/// ``frame->ext.payload`` is the object passed to
/// `nghttp2_submit_extension()` as payload parameter. Application
/// must pack extension payload to the |buf| of its capacity |len|
/// bytes. The |len| is at least 16KiB.
///
/// The implementation of this function should return the number of
/// bytes written into |buf| when it succeeds.
///
/// To abort processing this extension frame, return
/// :enum:`NGHTTP2_ERR_CANCEL`, and
/// :type:`nghttp2_on_frame_not_send_callback` will be invoked.
///
/// If fatal error occurred, application should return
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,
/// `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions
/// immediately return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If the
/// other values are returned, currently they are treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. If the return value is
/// strictly larger than |len|, it is treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`.
pub type nghttp2_pack_extension_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
buf: *mut u8,
len: usize,
frame: *const nghttp2_frame,
user_data: *mut ::std::os::raw::c_void,
) -> isize,
>;
/// @functypedef
///
/// Callback function invoked when library provides the error message
/// intended for human consumption. This callback is solely for
/// debugging purpose. The |msg| is typically NULL-terminated string
/// of length |len|. |len| does not include the sentinel NULL
/// character.
///
/// This function is deprecated. The new application should use
/// :type:`nghttp2_error_callback2`.
///
/// The format of error message may change between nghttp2 library
/// versions. The application should not depend on the particular
/// format.
///
/// Normally, application should return 0 from this callback. If fatal
/// error occurred while doing something in this callback, application
/// should return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,
/// library will return immediately with return value
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. Currently, if nonzero value
/// is returned from this callback, they are treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`, but application should not
/// rely on this details.
pub type nghttp2_error_callback = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
msg: *const ::std::os::raw::c_char,
len: usize,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
/// @functypedef
///
/// Callback function invoked when library provides the error code, and
/// message. This callback is solely for debugging purpose.
/// |lib_error_code| is one of error code defined in
/// :enum:`nghttp2_error`. The |msg| is typically NULL-terminated
/// string of length |len|, and intended for human consumption. |len|
/// does not include the sentinel NULL character.
///
/// The format of error message may change between nghttp2 library
/// versions. The application should not depend on the particular
/// format.
///
/// Normally, application should return 0 from this callback. If fatal
/// error occurred while doing something in this callback, application
/// should return :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,
/// library will return immediately with return value
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`. Currently, if nonzero value
/// is returned from this callback, they are treated as
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`, but application should not
/// rely on this details.
pub type nghttp2_error_callback2 = ::std::option::Option<
unsafe extern "C" fn(
session: *mut nghttp2_session,
lib_error_code: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
len: usize,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_session_callbacks {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Initializes |*callbacks_ptr| with NULL values.
///
/// The initialized object can be used when initializing multiple
/// :type:`nghttp2_session` objects.
///
/// When the application finished using this object, it can use
/// `nghttp2_session_callbacks_del()` to free its memory.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_callbacks_new(
callbacks_ptr: *mut *mut nghttp2_session_callbacks,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Frees any resources allocated for |callbacks|. If |callbacks| is
/// ``NULL``, this function does nothing.
pub fn nghttp2_session_callbacks_del(callbacks: *mut nghttp2_session_callbacks);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a session wants to send data to
/// the remote peer. This callback is not necessary if the application
/// uses solely `nghttp2_session_mem_send()` to serialize data to
/// transmit.
pub fn nghttp2_session_callbacks_set_send_callback(
cbs: *mut nghttp2_session_callbacks,
send_callback: nghttp2_send_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the a session wants to receive
/// data from the remote peer. This callback is not necessary if the
/// application uses solely `nghttp2_session_mem_recv()` to process
/// received data.
pub fn nghttp2_session_callbacks_set_recv_callback(
cbs: *mut nghttp2_session_callbacks,
recv_callback: nghttp2_recv_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked by `nghttp2_session_recv()` and
/// `nghttp2_session_mem_recv()` when a frame is received.
pub fn nghttp2_session_callbacks_set_on_frame_recv_callback(
cbs: *mut nghttp2_session_callbacks,
on_frame_recv_callback: nghttp2_on_frame_recv_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked by `nghttp2_session_recv()` and
/// `nghttp2_session_mem_recv()` when an invalid non-DATA frame is
/// received.
pub fn nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(
cbs: *mut nghttp2_session_callbacks,
on_invalid_frame_recv_callback: nghttp2_on_invalid_frame_recv_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a chunk of data in DATA frame
/// is received.
pub fn nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
cbs: *mut nghttp2_session_callbacks,
on_data_chunk_recv_callback: nghttp2_on_data_chunk_recv_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked before a non-DATA frame is sent.
pub fn nghttp2_session_callbacks_set_before_frame_send_callback(
cbs: *mut nghttp2_session_callbacks,
before_frame_send_callback: nghttp2_before_frame_send_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked after a frame is sent.
pub fn nghttp2_session_callbacks_set_on_frame_send_callback(
cbs: *mut nghttp2_session_callbacks,
on_frame_send_callback: nghttp2_on_frame_send_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a non-DATA frame is not sent
/// because of an error.
pub fn nghttp2_session_callbacks_set_on_frame_not_send_callback(
cbs: *mut nghttp2_session_callbacks,
on_frame_not_send_callback: nghttp2_on_frame_not_send_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the stream is closed.
pub fn nghttp2_session_callbacks_set_on_stream_close_callback(
cbs: *mut nghttp2_session_callbacks,
on_stream_close_callback: nghttp2_on_stream_close_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the reception of header block
/// in HEADERS or PUSH_PROMISE is started.
pub fn nghttp2_session_callbacks_set_on_begin_headers_callback(
cbs: *mut nghttp2_session_callbacks,
on_begin_headers_callback: nghttp2_on_begin_headers_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a header name/value pair is
/// received. If both
/// `nghttp2_session_callbacks_set_on_header_callback()` and
/// `nghttp2_session_callbacks_set_on_header_callback2()` are used to
/// set callbacks, the latter has the precedence.
pub fn nghttp2_session_callbacks_set_on_header_callback(
cbs: *mut nghttp2_session_callbacks,
on_header_callback: nghttp2_on_header_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a header name/value pair is
/// received.
pub fn nghttp2_session_callbacks_set_on_header_callback2(
cbs: *mut nghttp2_session_callbacks,
on_header_callback2: nghttp2_on_header_callback2,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a invalid header name/value
/// pair is received. If both
/// `nghttp2_session_callbacks_set_on_invalid_header_callback()` and
/// `nghttp2_session_callbacks_set_on_invalid_header_callback2()` are
/// used to set callbacks, the latter takes the precedence.
pub fn nghttp2_session_callbacks_set_on_invalid_header_callback(
cbs: *mut nghttp2_session_callbacks,
on_invalid_header_callback: nghttp2_on_invalid_header_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a invalid header name/value
/// pair is received.
pub fn nghttp2_session_callbacks_set_on_invalid_header_callback2(
cbs: *mut nghttp2_session_callbacks,
on_invalid_header_callback2: nghttp2_on_invalid_header_callback2,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the library asks application
/// how many padding bytes are required for the transmission of the
/// given frame.
pub fn nghttp2_session_callbacks_set_select_padding_callback(
cbs: *mut nghttp2_session_callbacks,
select_padding_callback: nghttp2_select_padding_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function determine the length allowed in
/// :type:`nghttp2_data_source_read_callback`.
pub fn nghttp2_session_callbacks_set_data_source_read_length_callback(
cbs: *mut nghttp2_session_callbacks,
data_source_read_length_callback: nghttp2_data_source_read_length_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when a frame header is received.
pub fn nghttp2_session_callbacks_set_on_begin_frame_callback(
cbs: *mut nghttp2_session_callbacks,
on_begin_frame_callback: nghttp2_on_begin_frame_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when
/// :enum:`NGHTTP2_DATA_FLAG_NO_COPY` is used in
/// :type:`nghttp2_data_source_read_callback` to avoid data copy.
pub fn nghttp2_session_callbacks_set_send_data_callback(
cbs: *mut nghttp2_session_callbacks,
send_data_callback: nghttp2_send_data_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the library asks the
/// application to pack extension frame payload in wire format.
pub fn nghttp2_session_callbacks_set_pack_extension_callback(
cbs: *mut nghttp2_session_callbacks,
pack_extension_callback: nghttp2_pack_extension_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when the library asks the
/// application to unpack extension frame payload from wire format.
pub fn nghttp2_session_callbacks_set_unpack_extension_callback(
cbs: *mut nghttp2_session_callbacks,
unpack_extension_callback: nghttp2_unpack_extension_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when chunk of extension frame
/// payload is received.
pub fn nghttp2_session_callbacks_set_on_extension_chunk_recv_callback(
cbs: *mut nghttp2_session_callbacks,
on_extension_chunk_recv_callback: nghttp2_on_extension_chunk_recv_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when library tells error message to
/// the application.
///
/// This function is deprecated. The new application should use
/// `nghttp2_session_callbacks_set_error_callback2()`.
///
/// If both :type:`nghttp2_error_callback` and
/// :type:`nghttp2_error_callback2` are set, the latter takes
/// precedence.
pub fn nghttp2_session_callbacks_set_error_callback(
cbs: *mut nghttp2_session_callbacks,
error_callback: nghttp2_error_callback,
);
}
extern "C" {
/// @function
///
/// Sets callback function invoked when library tells error code, and
/// message to the application.
///
/// If both :type:`nghttp2_error_callback` and
/// :type:`nghttp2_error_callback2` are set, the latter takes
/// precedence.
pub fn nghttp2_session_callbacks_set_error_callback2(
cbs: *mut nghttp2_session_callbacks,
error_callback2: nghttp2_error_callback2,
);
}
/// @functypedef
///
/// Custom memory allocator to replace malloc(). The |mem_user_data|
/// is the mem_user_data member of :type:`nghttp2_mem` structure.
pub type nghttp2_malloc = ::std::option::Option<
unsafe extern "C" fn(
size: usize,
mem_user_data: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
/// @functypedef
///
/// Custom memory allocator to replace free(). The |mem_user_data| is
/// the mem_user_data member of :type:`nghttp2_mem` structure.
pub type nghttp2_free = ::std::option::Option<
unsafe extern "C" fn(
ptr: *mut ::std::os::raw::c_void,
mem_user_data: *mut ::std::os::raw::c_void,
),
>;
/// @functypedef
///
/// Custom memory allocator to replace calloc(). The |mem_user_data|
/// is the mem_user_data member of :type:`nghttp2_mem` structure.
pub type nghttp2_calloc = ::std::option::Option<
unsafe extern "C" fn(
nmemb: usize,
size: usize,
mem_user_data: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
/// @functypedef
///
/// Custom memory allocator to replace realloc(). The |mem_user_data|
/// is the mem_user_data member of :type:`nghttp2_mem` structure.
pub type nghttp2_realloc = ::std::option::Option<
unsafe extern "C" fn(
ptr: *mut ::std::os::raw::c_void,
size: usize,
mem_user_data: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
/// @struct
///
/// Custom memory allocator functions and user defined pointer. The
/// |mem_user_data| member is passed to each allocator function. This
/// can be used, for example, to achieve per-session memory pool.
///
/// In the following example code, ``my_malloc``, ``my_free``,
/// ``my_calloc`` and ``my_realloc`` are the replacement of the
/// standard allocators ``malloc``, ``free``, ``calloc`` and
/// ``realloc`` respectively::
///
/// void *my_malloc_cb(size_t size, void *mem_user_data) {
/// return my_malloc(size);
/// }
///
/// void my_free_cb(void *ptr, void *mem_user_data) { my_free(ptr); }
///
/// void *my_calloc_cb(size_t nmemb, size_t size, void *mem_user_data) {
/// return my_calloc(nmemb, size);
/// }
///
/// void *my_realloc_cb(void *ptr, size_t size, void *mem_user_data) {
/// return my_realloc(ptr, size);
/// }
///
/// void session_new() {
/// nghttp2_session *session;
/// nghttp2_session_callbacks *callbacks;
/// nghttp2_mem mem = {NULL, my_malloc_cb, my_free_cb, my_calloc_cb,
/// my_realloc_cb};
///
/// ...
///
/// nghttp2_session_client_new3(&session, callbacks, NULL, NULL, &mem);
///
/// ...
/// }
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_mem {
/// An arbitrary user supplied data. This is passed to each
/// allocator function.
pub mem_user_data: *mut ::std::os::raw::c_void,
/// Custom allocator function to replace malloc().
pub malloc: nghttp2_malloc,
/// Custom allocator function to replace free().
pub free: nghttp2_free,
/// Custom allocator function to replace calloc().
pub calloc: nghttp2_calloc,
/// Custom allocator function to replace realloc().
pub realloc: nghttp2_realloc,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_option {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Initializes |*option_ptr| with default values.
///
/// When the application finished using this object, it can use
/// `nghttp2_option_del()` to free its memory.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_option_new(option_ptr: *mut *mut nghttp2_option) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Frees any resources allocated for |option|. If |option| is
/// ``NULL``, this function does nothing.
pub fn nghttp2_option_del(option: *mut nghttp2_option);
}
extern "C" {
/// @function
///
/// This option prevents the library from sending WINDOW_UPDATE for a
/// connection automatically. If this option is set to nonzero, the
/// library won't send WINDOW_UPDATE for DATA until application calls
/// `nghttp2_session_consume()` to indicate the consumed amount of
/// data. Don't use `nghttp2_submit_window_update()` for this purpose.
/// By default, this option is set to zero.
pub fn nghttp2_option_set_no_auto_window_update(
option: *mut nghttp2_option,
val: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// This option sets the SETTINGS_MAX_CONCURRENT_STREAMS value of
/// remote endpoint as if it is received in SETTINGS frame. Without
/// specifying this option, the maximum number of outgoing concurrent
/// streams is initially limited to 100 to avoid issues when the local
/// endpoint submits lots of requests before receiving initial SETTINGS
/// frame from the remote endpoint, since sending them at once to the
/// remote endpoint could lead to rejection of some of the requests.
/// This value will be overwritten when the local endpoint receives
/// initial SETTINGS frame from the remote endpoint, either to the
/// value advertised in SETTINGS_MAX_CONCURRENT_STREAMS or to the
/// default value (unlimited) if none was advertised.
pub fn nghttp2_option_set_peer_max_concurrent_streams(option: *mut nghttp2_option, val: u32);
}
extern "C" {
/// @function
///
/// By default, nghttp2 library, if configured as server, requires
/// first 24 bytes of client magic byte string (MAGIC). In most cases,
/// this will simplify the implementation of server. But sometimes
/// server may want to detect the application protocol based on first
/// few bytes on clear text communication.
///
/// If this option is used with nonzero |val|, nghttp2 library does not
/// handle MAGIC. It still checks following SETTINGS frame. This
/// means that applications should deal with MAGIC by themselves.
///
/// If this option is not used or used with zero value, if MAGIC does
/// not match :macro:`NGHTTP2_CLIENT_MAGIC`, `nghttp2_session_recv()`
/// and `nghttp2_session_mem_recv()` will return error
/// :enum:`NGHTTP2_ERR_BAD_CLIENT_MAGIC`, which is fatal error.
pub fn nghttp2_option_set_no_recv_client_magic(
option: *mut nghttp2_option,
val: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// By default, nghttp2 library enforces subset of HTTP Messaging rules
/// described in `HTTP/2 specification, section 8
/// <https://tools.ietf.org/html/rfc7540#section-8>`_. See
/// :ref:`http-messaging` section for details. For those applications
/// who use nghttp2 library as non-HTTP use, give nonzero to |val| to
/// disable this enforcement. Please note that disabling this feature
/// does not change the fundamental client and server model of HTTP.
/// That is, even if the validation is disabled, only client can send
/// requests.
pub fn nghttp2_option_set_no_http_messaging(
option: *mut nghttp2_option,
val: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// RFC 7540 does not enforce any limit on the number of incoming
/// reserved streams (in RFC 7540 terms, streams in reserved (remote)
/// state). This only affects client side, since only server can push
/// streams. Malicious server can push arbitrary number of streams,
/// and make client's memory exhausted. This option can set the
/// maximum number of such incoming streams to avoid possible memory
/// exhaustion. If this option is set, and pushed streams are
/// automatically closed on reception, without calling user provided
/// callback, if they exceed the given limit. The default value is
/// 200. If session is configured as server side, this option has no
/// effect. Server can control the number of streams to push.
pub fn nghttp2_option_set_max_reserved_remote_streams(option: *mut nghttp2_option, val: u32);
}
extern "C" {
/// @function
///
/// Sets extension frame type the application is willing to handle with
/// user defined callbacks (see
/// :type:`nghttp2_on_extension_chunk_recv_callback` and
/// :type:`nghttp2_unpack_extension_callback`). The |type| is
/// extension frame type, and must be strictly greater than 0x9.
/// Otherwise, this function does nothing. The application can call
/// this function multiple times to set more than one frame type to
/// receive. The application does not have to call this function if it
/// just sends extension frames.
pub fn nghttp2_option_set_user_recv_extension_type(option: *mut nghttp2_option, type_: u8);
}
extern "C" {
/// @function
///
/// Sets extension frame type the application is willing to receive
/// using builtin handler. The |type| is the extension frame type to
/// receive, and must be strictly greater than 0x9. Otherwise, this
/// function does nothing. The application can call this function
/// multiple times to set more than one frame type to receive. The
/// application does not have to call this function if it just sends
/// extension frames.
///
/// If same frame type is passed to both
/// `nghttp2_option_set_builtin_recv_extension_type()` and
/// `nghttp2_option_set_user_recv_extension_type()`, the latter takes
/// precedence.
pub fn nghttp2_option_set_builtin_recv_extension_type(option: *mut nghttp2_option, type_: u8);
}
extern "C" {
/// @function
///
/// This option prevents the library from sending PING frame with ACK
/// flag set automatically when PING frame without ACK flag set is
/// received. If this option is set to nonzero, the library won't send
/// PING frame with ACK flag set in the response for incoming PING
/// frame. The application can send PING frame with ACK flag set using
/// `nghttp2_submit_ping()` with :enum:`NGHTTP2_FLAG_ACK` as flags
/// parameter.
pub fn nghttp2_option_set_no_auto_ping_ack(
option: *mut nghttp2_option,
val: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// This option sets the maximum length of header block (a set of
/// header fields per one HEADERS frame) to send. The length of a
/// given set of header fields is calculated using
/// `nghttp2_hd_deflate_bound()`. The default value is 64KiB. If
/// application attempts to send header fields larger than this limit,
/// the transmission of the frame fails with error code
/// :enum:`NGHTTP2_ERR_FRAME_SIZE_ERROR`.
pub fn nghttp2_option_set_max_send_header_block_length(option: *mut nghttp2_option, val: usize);
}
extern "C" {
/// @function
///
/// This option sets the maximum dynamic table size for deflating
/// header fields. The default value is 4KiB. In HTTP/2, receiver of
/// deflated header block can specify maximum dynamic table size. The
/// actual maximum size is the minimum of the size receiver specified
/// and this option value.
pub fn nghttp2_option_set_max_deflate_dynamic_table_size(
option: *mut nghttp2_option,
val: usize,
);
}
extern "C" {
/// @function
///
/// This option prevents the library from retaining closed streams to
/// maintain the priority tree. If this option is set to nonzero,
/// applications can discard closed stream completely to save memory.
pub fn nghttp2_option_set_no_closed_streams(
option: *mut nghttp2_option,
val: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// Initializes |*session_ptr| for client use. The all members of
/// |callbacks| are copied to |*session_ptr|. Therefore |*session_ptr|
/// does not store |callbacks|. The |user_data| is an arbitrary user
/// supplied data, which will be passed to the callback functions.
///
/// The :type:`nghttp2_send_callback` must be specified. If the
/// application code uses `nghttp2_session_recv()`, the
/// :type:`nghttp2_recv_callback` must be specified. The other members
/// of |callbacks| can be ``NULL``.
///
/// If this function fails, |*session_ptr| is left untouched.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_client_new(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Initializes |*session_ptr| for server use. The all members of
/// |callbacks| are copied to |*session_ptr|. Therefore |*session_ptr|
/// does not store |callbacks|. The |user_data| is an arbitrary user
/// supplied data, which will be passed to the callback functions.
///
/// The :type:`nghttp2_send_callback` must be specified. If the
/// application code uses `nghttp2_session_recv()`, the
/// :type:`nghttp2_recv_callback` must be specified. The other members
/// of |callbacks| can be ``NULL``.
///
/// If this function fails, |*session_ptr| is left untouched.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_server_new(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_client_new()`, but with additional options
/// specified in the |option|.
///
/// The |option| can be ``NULL`` and the call is equivalent to
/// `nghttp2_session_client_new()`.
///
/// This function does not take ownership |option|. The application is
/// responsible for freeing |option| if it finishes using the object.
///
/// The library code does not refer to |option| after this function
/// returns.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_client_new2(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
option: *const nghttp2_option,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_server_new()`, but with additional options
/// specified in the |option|.
///
/// The |option| can be ``NULL`` and the call is equivalent to
/// `nghttp2_session_server_new()`.
///
/// This function does not take ownership |option|. The application is
/// responsible for freeing |option| if it finishes using the object.
///
/// The library code does not refer to |option| after this function
/// returns.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_server_new2(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
option: *const nghttp2_option,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_client_new2()`, but with additional custom
/// memory allocator specified in the |mem|.
///
/// The |mem| can be ``NULL`` and the call is equivalent to
/// `nghttp2_session_client_new2()`.
///
/// This function does not take ownership |mem|. The application is
/// responsible for freeing |mem|.
///
/// The library code does not refer to |mem| pointer after this
/// function returns, so the application can safely free it.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_client_new3(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
option: *const nghttp2_option,
mem: *mut nghttp2_mem,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_server_new2()`, but with additional custom
/// memory allocator specified in the |mem|.
///
/// The |mem| can be ``NULL`` and the call is equivalent to
/// `nghttp2_session_server_new2()`.
///
/// This function does not take ownership |mem|. The application is
/// responsible for freeing |mem|.
///
/// The library code does not refer to |mem| pointer after this
/// function returns, so the application can safely free it.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_server_new3(
session_ptr: *mut *mut nghttp2_session,
callbacks: *const nghttp2_session_callbacks,
user_data: *mut ::std::os::raw::c_void,
option: *const nghttp2_option,
mem: *mut nghttp2_mem,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Frees any resources allocated for |session|. If |session| is
/// ``NULL``, this function does nothing.
pub fn nghttp2_session_del(session: *mut nghttp2_session);
}
extern "C" {
/// @function
///
/// Sends pending frames to the remote peer.
///
/// This function retrieves the highest prioritized frame from the
/// outbound queue and sends it to the remote peer. It does this as
/// many as possible until the user callback
/// :type:`nghttp2_send_callback` returns
/// :enum:`NGHTTP2_ERR_WOULDBLOCK` or the outbound queue becomes empty.
/// This function calls several callback functions which are passed
/// when initializing the |session|. Here is the simple time chart
/// which tells when each callback is invoked:
///
/// 1. Get the next frame to send from outbound queue.
///
/// 2. Prepare transmission of the frame.
///
/// 3. If the control frame cannot be sent because some preconditions
/// are not met (e.g., request HEADERS cannot be sent after GOAWAY),
/// :type:`nghttp2_on_frame_not_send_callback` is invoked. Abort
/// the following steps.
///
/// 4. If the frame is HEADERS, PUSH_PROMISE or DATA,
/// :type:`nghttp2_select_padding_callback` is invoked.
///
/// 5. If the frame is request HEADERS, the stream is opened here.
///
/// 6. :type:`nghttp2_before_frame_send_callback` is invoked.
///
/// 7. If :enum:`NGHTTP2_ERR_CANCEL` is returned from
/// :type:`nghttp2_before_frame_send_callback`, the current frame
/// transmission is canceled, and
/// :type:`nghttp2_on_frame_not_send_callback` is invoked. Abort
/// the following steps.
///
/// 8. :type:`nghttp2_send_callback` is invoked one or more times to
/// send the frame.
///
/// 9. :type:`nghttp2_on_frame_send_callback` is invoked.
///
/// 10. If the transmission of the frame triggers closure of the
/// stream, the stream is closed and
/// :type:`nghttp2_on_stream_close_callback` is invoked.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`
/// The callback function failed.
pub fn nghttp2_session_send(session: *mut nghttp2_session) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the serialized data to send.
///
/// This function behaves like `nghttp2_session_send()` except that it
/// does not use :type:`nghttp2_send_callback` to transmit data.
/// Instead, it assigns the pointer to the serialized data to the
/// |*data_ptr| and returns its length. The other callbacks are called
/// in the same way as they are in `nghttp2_session_send()`.
///
/// If no data is available to send, this function returns 0.
///
/// This function may not return all serialized data in one invocation.
/// To get all data, call this function repeatedly until it returns 0
/// or one of negative error codes.
///
/// The assigned |*data_ptr| is valid until the next call of
/// `nghttp2_session_mem_send()` or `nghttp2_session_send()`.
///
/// The caller must send all data before sending the next chunk of
/// data.
///
/// This function returns the length of the data pointed by the
/// |*data_ptr| if it succeeds, or one of the following negative error
/// codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
///
/// .. note::
///
/// This function may produce very small byte string. If that is the
/// case, and application disables Nagle algorithm (``TCP_NODELAY``),
/// then writing this small chunk leads to very small packet, and it
/// is very inefficient. An application should be responsible to
/// buffer up small chunks of data as necessary to avoid this
/// situation.
pub fn nghttp2_session_mem_send(
session: *mut nghttp2_session,
data_ptr: *mut *const u8,
) -> isize;
}
extern "C" {
/// @function
///
/// Receives frames from the remote peer.
///
/// This function receives as many frames as possible until the user
/// callback :type:`nghttp2_recv_callback` returns
/// :enum:`NGHTTP2_ERR_WOULDBLOCK`. This function calls several
/// callback functions which are passed when initializing the
/// |session|. Here is the simple time chart which tells when each
/// callback is invoked:
///
/// 1. :type:`nghttp2_recv_callback` is invoked one or more times to
/// receive frame header.
///
/// 2. When frame header is received,
/// :type:`nghttp2_on_begin_frame_callback` is invoked.
///
/// 3. If the frame is DATA frame:
///
/// 1. :type:`nghttp2_recv_callback` is invoked to receive DATA
/// payload. For each chunk of data,
/// :type:`nghttp2_on_data_chunk_recv_callback` is invoked.
///
/// 2. If one DATA frame is completely received,
/// :type:`nghttp2_on_frame_recv_callback` is invoked. If the
/// reception of the frame triggers the closure of the stream,
/// :type:`nghttp2_on_stream_close_callback` is invoked.
///
/// 4. If the frame is the control frame:
///
/// 1. :type:`nghttp2_recv_callback` is invoked one or more times to
/// receive whole frame.
///
/// 2. If the received frame is valid, then following actions are
/// taken. If the frame is either HEADERS or PUSH_PROMISE,
/// :type:`nghttp2_on_begin_headers_callback` is invoked. Then
/// :type:`nghttp2_on_header_callback` is invoked for each header
/// name/value pair. For invalid header field,
/// :type:`nghttp2_on_invalid_header_callback` is called. After
/// all name/value pairs are emitted successfully,
/// :type:`nghttp2_on_frame_recv_callback` is invoked. For other
/// frames, :type:`nghttp2_on_frame_recv_callback` is invoked.
/// If the reception of the frame triggers the closure of the
/// stream, :type:`nghttp2_on_stream_close_callback` is invoked.
///
/// 3. If the received frame is unpacked but is interpreted as
/// invalid, :type:`nghttp2_on_invalid_frame_recv_callback` is
/// invoked.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_EOF`
/// The remote peer did shutdown on the connection.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`
/// The callback function failed.
/// :enum:`NGHTTP2_ERR_BAD_CLIENT_MAGIC`
/// Invalid client magic was detected. This error only returns
/// when |session| was configured as server and
/// `nghttp2_option_set_no_recv_client_magic()` is not used with
/// nonzero value.
/// :enum:`NGHTTP2_ERR_FLOODED`
/// Flooding was detected in this HTTP/2 session, and it must be
/// closed. This is most likely caused by misbehaviour of peer.
pub fn nghttp2_session_recv(session: *mut nghttp2_session) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Processes data |in| as an input from the remote endpoint. The
/// |inlen| indicates the number of bytes in the |in|.
///
/// This function behaves like `nghttp2_session_recv()` except that it
/// does not use :type:`nghttp2_recv_callback` to receive data; the
/// |in| is the only data for the invocation of this function. If all
/// bytes are processed, this function returns. The other callbacks
/// are called in the same way as they are in `nghttp2_session_recv()`.
///
/// In the current implementation, this function always tries to
/// processes all input data unless either an error occurs or
/// :enum:`NGHTTP2_ERR_PAUSE` is returned from
/// :type:`nghttp2_on_header_callback` or
/// :type:`nghttp2_on_data_chunk_recv_callback`. If
/// :enum:`NGHTTP2_ERR_PAUSE` is used, the return value includes the
/// number of bytes which was used to produce the data or frame for the
/// callback.
///
/// This function returns the number of processed bytes, or one of the
/// following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_CALLBACK_FAILURE`
/// The callback function failed.
/// :enum:`NGHTTP2_ERR_BAD_CLIENT_MAGIC`
/// Invalid client magic was detected. This error only returns
/// when |session| was configured as server and
/// `nghttp2_option_set_no_recv_client_magic()` is not used with
/// nonzero value.
/// :enum:`NGHTTP2_ERR_FLOODED`
/// Flooding was detected in this HTTP/2 session, and it must be
/// closed. This is most likely caused by misbehaviour of peer.
pub fn nghttp2_session_mem_recv(
session: *mut nghttp2_session,
in_: *const u8,
inlen: usize,
) -> isize;
}
extern "C" {
/// @function
///
/// Puts back previously deferred DATA frame in the stream |stream_id|
/// to the outbound queue.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The stream does not exist; or no deferred data exist.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_resume_data(
session: *mut nghttp2_session,
stream_id: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns nonzero value if |session| wants to receive data from the
/// remote peer.
///
/// If both `nghttp2_session_want_read()` and
/// `nghttp2_session_want_write()` return 0, the application should
/// drop the connection.
pub fn nghttp2_session_want_read(session: *mut nghttp2_session) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns nonzero value if |session| wants to send data to the remote
/// peer.
///
/// If both `nghttp2_session_want_read()` and
/// `nghttp2_session_want_write()` return 0, the application should
/// drop the connection.
pub fn nghttp2_session_want_write(session: *mut nghttp2_session) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns stream_user_data for the stream |stream_id|. The
/// stream_user_data is provided by `nghttp2_submit_request()`,
/// `nghttp2_submit_headers()` or
/// `nghttp2_session_set_stream_user_data()`. Unless it is set using
/// `nghttp2_session_set_stream_user_data()`, if the stream is
/// initiated by the remote endpoint, stream_user_data is always
/// ``NULL``. If the stream does not exist, this function returns
/// ``NULL``.
pub fn nghttp2_session_get_stream_user_data(
session: *mut nghttp2_session,
stream_id: i32,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
/// @function
///
/// Sets the |stream_user_data| to the stream denoted by the
/// |stream_id|. If a stream user data is already set to the stream,
/// it is replaced with the |stream_user_data|. It is valid to specify
/// ``NULL`` in the |stream_user_data|, which nullifies the associated
/// data pointer.
///
/// It is valid to set the |stream_user_data| to the stream reserved by
/// PUSH_PROMISE frame.
///
/// This function returns 0 if it succeeds, or one of following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The stream does not exist
pub fn nghttp2_session_set_stream_user_data(
session: *mut nghttp2_session,
stream_id: i32,
stream_user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Sets |user_data| to |session|, overwriting the existing user data
/// specified in `nghttp2_session_client_new()`, or
/// `nghttp2_session_server_new()`.
pub fn nghttp2_session_set_user_data(
session: *mut nghttp2_session,
user_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
/// @function
///
/// Returns the number of frames in the outbound queue. This does not
/// include the deferred DATA frames.
pub fn nghttp2_session_get_outbound_queue_size(session: *mut nghttp2_session) -> usize;
}
extern "C" {
/// @function
///
/// Returns the number of DATA payload in bytes received without
/// WINDOW_UPDATE transmission for the stream |stream_id|. The local
/// (receive) window size can be adjusted by
/// `nghttp2_submit_window_update()`. This function takes into account
/// that and returns effective data length. In particular, if the
/// local window size is reduced by submitting negative
/// window_size_increment with `nghttp2_submit_window_update()`, this
/// function returns the number of bytes less than actually received.
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_stream_effective_recv_data_length(
session: *mut nghttp2_session,
stream_id: i32,
) -> i32;
}
extern "C" {
/// @function
///
/// Returns the local (receive) window size for the stream |stream_id|.
/// The local window size can be adjusted by
/// `nghttp2_submit_window_update()`. This function takes into account
/// that and returns effective window size.
///
/// This function does not take into account the amount of received
/// data from the remote endpoint. Use
/// `nghttp2_session_get_stream_local_window_size()` to know the amount
/// of data the remote endpoint can send without receiving stream level
/// WINDOW_UPDATE frame. Note that each stream is still subject to the
/// connection level flow control.
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_stream_effective_local_window_size(
session: *mut nghttp2_session,
stream_id: i32,
) -> i32;
}
extern "C" {
/// @function
///
/// Returns the amount of flow-controlled payload (e.g., DATA) that the
/// remote endpoint can send without receiving stream level
/// WINDOW_UPDATE frame. It is also subject to the connection level
/// flow control. So the actual amount of data to send is
/// min(`nghttp2_session_get_stream_local_window_size()`,
/// `nghttp2_session_get_local_window_size()`).
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_stream_local_window_size(
session: *mut nghttp2_session,
stream_id: i32,
) -> i32;
}
extern "C" {
/// @function
///
/// Returns the number of DATA payload in bytes received without
/// WINDOW_UPDATE transmission for a connection. The local (receive)
/// window size can be adjusted by `nghttp2_submit_window_update()`.
/// This function takes into account that and returns effective data
/// length. In particular, if the local window size is reduced by
/// submitting negative window_size_increment with
/// `nghttp2_submit_window_update()`, this function returns the number
/// of bytes less than actually received.
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_effective_recv_data_length(session: *mut nghttp2_session) -> i32;
}
extern "C" {
/// @function
///
/// Returns the local (receive) window size for a connection. The
/// local window size can be adjusted by
/// `nghttp2_submit_window_update()`. This function takes into account
/// that and returns effective window size.
///
/// This function does not take into account the amount of received
/// data from the remote endpoint. Use
/// `nghttp2_session_get_local_window_size()` to know the amount of
/// data the remote endpoint can send without receiving
/// connection-level WINDOW_UPDATE frame. Note that each stream is
/// still subject to the stream level flow control.
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_effective_local_window_size(session: *mut nghttp2_session) -> i32;
}
extern "C" {
/// @function
///
/// Returns the amount of flow-controlled payload (e.g., DATA) that the
/// remote endpoint can send without receiving connection level
/// WINDOW_UPDATE frame. Note that each stream is still subject to the
/// stream level flow control (see
/// `nghttp2_session_get_stream_local_window_size()`).
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_local_window_size(session: *mut nghttp2_session) -> i32;
}
extern "C" {
/// @function
///
/// Returns the remote window size for a given stream |stream_id|.
///
/// This is the amount of flow-controlled payload (e.g., DATA) that the
/// local endpoint can send without stream level WINDOW_UPDATE. There
/// is also connection level flow control, so the effective size of
/// payload that the local endpoint can actually send is
/// min(`nghttp2_session_get_stream_remote_window_size()`,
/// `nghttp2_session_get_remote_window_size()`).
///
/// This function returns -1 if it fails.
pub fn nghttp2_session_get_stream_remote_window_size(
session: *mut nghttp2_session,
stream_id: i32,
) -> i32;
}
extern "C" {
/// @function
///
/// Returns the remote window size for a connection.
///
/// This function always succeeds.
pub fn nghttp2_session_get_remote_window_size(session: *mut nghttp2_session) -> i32;
}
extern "C" {
/// @function
///
/// Returns 1 if local peer half closed the given stream |stream_id|.
/// Returns 0 if it did not. Returns -1 if no such stream exists.
pub fn nghttp2_session_get_stream_local_close(
session: *mut nghttp2_session,
stream_id: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns 1 if remote peer half closed the given stream |stream_id|.
/// Returns 0 if it did not. Returns -1 if no such stream exists.
pub fn nghttp2_session_get_stream_remote_close(
session: *mut nghttp2_session,
stream_id: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the current dynamic table size of HPACK inflater, including
/// the overhead 32 bytes per entry described in RFC 7541.
pub fn nghttp2_session_get_hd_inflate_dynamic_table_size(
session: *mut nghttp2_session,
) -> usize;
}
extern "C" {
/// @function
///
/// Returns the current dynamic table size of HPACK deflater including
/// the overhead 32 bytes per entry described in RFC 7541.
pub fn nghttp2_session_get_hd_deflate_dynamic_table_size(
session: *mut nghttp2_session,
) -> usize;
}
extern "C" {
/// @function
///
/// Signals the session so that the connection should be terminated.
///
/// The last stream ID is the minimum value between the stream ID of a
/// stream for which :type:`nghttp2_on_frame_recv_callback` was called
/// most recently and the last stream ID we have sent to the peer
/// previously.
///
/// The |error_code| is the error code of this GOAWAY frame. The
/// pre-defined error code is one of :enum:`nghttp2_error_code`.
///
/// After the transmission, both `nghttp2_session_want_read()` and
/// `nghttp2_session_want_write()` return 0.
///
/// This function should be called when the connection should be
/// terminated after sending GOAWAY. If the remaining streams should
/// be processed after GOAWAY, use `nghttp2_submit_goaway()` instead.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_terminate_session(
session: *mut nghttp2_session,
error_code: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Signals the session so that the connection should be terminated.
///
/// This function behaves like `nghttp2_session_terminate_session()`,
/// but the last stream ID can be specified by the application for fine
/// grained control of stream. The HTTP/2 specification does not allow
/// last_stream_id to be increased. So the actual value sent as
/// last_stream_id is the minimum value between the given
/// |last_stream_id| and the last_stream_id we have previously sent to
/// the peer.
///
/// The |last_stream_id| is peer's stream ID or 0. So if |session| is
/// initialized as client, |last_stream_id| must be even or 0. If
/// |session| is initialized as server, |last_stream_id| must be odd or
/// 0.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |last_stream_id| is invalid.
pub fn nghttp2_session_terminate_session2(
session: *mut nghttp2_session,
last_stream_id: i32,
error_code: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Signals to the client that the server started graceful shutdown
/// procedure.
///
/// This function is only usable for server. If this function is
/// called with client side session, this function returns
/// :enum:`NGHTTP2_ERR_INVALID_STATE`.
///
/// To gracefully shutdown HTTP/2 session, server should call this
/// function to send GOAWAY with last_stream_id (1u << 31) - 1. And
/// after some delay (e.g., 1 RTT), send another GOAWAY with the stream
/// ID that the server has some processing using
/// `nghttp2_submit_goaway()`. See also
/// `nghttp2_session_get_last_proc_stream_id()`.
///
/// Unlike `nghttp2_submit_goaway()`, this function just sends GOAWAY
/// and does nothing more. This is a mere indication to the client
/// that session shutdown is imminent. The application should call
/// `nghttp2_submit_goaway()` with appropriate last_stream_id after
/// this call.
///
/// If one or more GOAWAY frame have been already sent by either
/// `nghttp2_submit_goaway()` or `nghttp2_session_terminate_session()`,
/// this function has no effect.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// The |session| is initialized as client.
pub fn nghttp2_submit_shutdown_notice(session: *mut nghttp2_session) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the value of SETTINGS |id| notified by a remote endpoint.
/// The |id| must be one of values defined in
/// :enum:`nghttp2_settings_id`.
pub fn nghttp2_session_get_remote_settings(
session: *mut nghttp2_session,
id: nghttp2_settings_id,
) -> u32;
}
extern "C" {
/// @function
///
/// Returns the value of SETTINGS |id| of local endpoint acknowledged
/// by the remote endpoint. The |id| must be one of the values defined
/// in :enum:`nghttp2_settings_id`.
pub fn nghttp2_session_get_local_settings(
session: *mut nghttp2_session,
id: nghttp2_settings_id,
) -> u32;
}
extern "C" {
/// @function
///
/// Tells the |session| that next stream ID is |next_stream_id|. The
/// |next_stream_id| must be equal or greater than the value returned
/// by `nghttp2_session_get_next_stream_id()`.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |next_stream_id| is strictly less than the value
/// `nghttp2_session_get_next_stream_id()` returns; or
/// |next_stream_id| is invalid (e.g., even integer for client, or
/// odd integer for server).
pub fn nghttp2_session_set_next_stream_id(
session: *mut nghttp2_session,
next_stream_id: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the next outgoing stream ID. Notice that return type is
/// uint32_t. If we run out of stream ID for this session, this
/// function returns 1 << 31.
pub fn nghttp2_session_get_next_stream_id(session: *mut nghttp2_session) -> u32;
}
extern "C" {
/// @function
///
/// Tells the |session| that |size| bytes for a stream denoted by
/// |stream_id| were consumed by application and are ready to
/// WINDOW_UPDATE. The consumed bytes are counted towards both
/// connection and stream level WINDOW_UPDATE (see
/// `nghttp2_session_consume_connection()` and
/// `nghttp2_session_consume_stream()` to update consumption
/// independently). This function is intended to be used without
/// automatic window update (see
/// `nghttp2_option_set_no_auto_window_update()`).
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// Automatic WINDOW_UPDATE is not disabled.
pub fn nghttp2_session_consume(
session: *mut nghttp2_session,
stream_id: i32,
size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_consume()`, but this only tells library that
/// |size| bytes were consumed only for connection level. Note that
/// HTTP/2 maintains connection and stream level flow control windows
/// independently.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// Automatic WINDOW_UPDATE is not disabled.
pub fn nghttp2_session_consume_connection(
session: *mut nghttp2_session,
size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_session_consume()`, but this only tells library that
/// |size| bytes were consumed only for stream denoted by |stream_id|.
/// Note that HTTP/2 maintains connection and stream level flow control
/// windows independently.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// Automatic WINDOW_UPDATE is not disabled.
pub fn nghttp2_session_consume_stream(
session: *mut nghttp2_session,
stream_id: i32,
size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Changes priority of existing stream denoted by |stream_id|. The
/// new priority specification is |pri_spec|.
///
/// The priority is changed silently and instantly, and no PRIORITY
/// frame will be sent to notify the peer of this change. This
/// function may be useful for server to change the priority of pushed
/// stream.
///
/// If |session| is initialized as server, and ``pri_spec->stream_id``
/// points to the idle stream, the idle stream is created if it does
/// not exist. The created idle stream will depend on root stream
/// (stream 0) with weight 16.
///
/// Otherwise, if stream denoted by ``pri_spec->stream_id`` is not
/// found, we use default priority instead of given |pri_spec|. That
/// is make stream depend on root stream with weight 16.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// Attempted to depend on itself; or no stream exist for the given
/// |stream_id|; or |stream_id| is 0
pub fn nghttp2_session_change_stream_priority(
session: *mut nghttp2_session,
stream_id: i32,
pri_spec: *const nghttp2_priority_spec,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Creates idle stream with the given |stream_id|, and priority
/// |pri_spec|.
///
/// The stream creation is done without sending PRIORITY frame, which
/// means that peer does not know about the existence of this idle
/// stream in the local endpoint.
///
/// RFC 7540 does not disallow the use of creation of idle stream with
/// odd or even stream ID regardless of client or server. So this
/// function can create odd or even stream ID regardless of client or
/// server. But probably it is a bit safer to use the stream ID the
/// local endpoint can initiate (in other words, use odd stream ID for
/// client, and even stream ID for server), to avoid potential
/// collision from peer's instruction. Also we can use
/// `nghttp2_session_set_next_stream_id()` to avoid to open created
/// idle streams accidentally if we follow this recommendation.
///
/// If |session| is initialized as server, and ``pri_spec->stream_id``
/// points to the idle stream, the idle stream is created if it does
/// not exist. The created idle stream will depend on root stream
/// (stream 0) with weight 16.
///
/// Otherwise, if stream denoted by ``pri_spec->stream_id`` is not
/// found, we use default priority instead of given |pri_spec|. That
/// is make stream depend on root stream with weight 16.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// Attempted to depend on itself; or stream denoted by |stream_id|
/// already exists; or |stream_id| cannot be used to create idle
/// stream (in other words, local endpoint has already opened
/// stream ID greater than or equal to the given stream ID; or
/// |stream_id| is 0
pub fn nghttp2_session_create_idle_stream(
session: *mut nghttp2_session,
stream_id: i32,
pri_spec: *const nghttp2_priority_spec,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Performs post-process of HTTP Upgrade request. This function can
/// be called from both client and server, but the behavior is very
/// different in each other.
///
/// .. warning::
///
/// This function is deprecated in favor of
/// `nghttp2_session_upgrade2()`, because this function lacks the
/// parameter to tell the library the request method used in the
/// original HTTP request. This information is required for client
/// to validate actual response body length against content-length
/// header field (see `nghttp2_option_set_no_http_messaging()`). If
/// HEAD is used in request, the length of response body must be 0
/// regardless of value included in content-length header field.
///
/// If called from client side, the |settings_payload| must be the
/// value sent in ``HTTP2-Settings`` header field and must be decoded
/// by base64url decoder. The |settings_payloadlen| is the length of
/// |settings_payload|. The |settings_payload| is unpacked and its
/// setting values will be submitted using `nghttp2_submit_settings()`.
/// This means that the client application code does not need to submit
/// SETTINGS by itself. The stream with stream ID=1 is opened and the
/// |stream_user_data| is used for its stream_user_data. The opened
/// stream becomes half-closed (local) state.
///
/// If called from server side, the |settings_payload| must be the
/// value received in ``HTTP2-Settings`` header field and must be
/// decoded by base64url decoder. The |settings_payloadlen| is the
/// length of |settings_payload|. It is treated as if the SETTINGS
/// frame with that payload is received. Thus, callback functions for
/// the reception of SETTINGS frame will be invoked. The stream with
/// stream ID=1 is opened. The |stream_user_data| is ignored. The
/// opened stream becomes half-closed (remote).
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |settings_payload| is badly formed.
/// :enum:`NGHTTP2_ERR_PROTO`
/// The stream ID 1 is already used or closed; or is not available.
pub fn nghttp2_session_upgrade(
session: *mut nghttp2_session,
settings_payload: *const u8,
settings_payloadlen: usize,
stream_user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Performs post-process of HTTP Upgrade request. This function can
/// be called from both client and server, but the behavior is very
/// different in each other.
///
/// If called from client side, the |settings_payload| must be the
/// value sent in ``HTTP2-Settings`` header field and must be decoded
/// by base64url decoder. The |settings_payloadlen| is the length of
/// |settings_payload|. The |settings_payload| is unpacked and its
/// setting values will be submitted using `nghttp2_submit_settings()`.
/// This means that the client application code does not need to submit
/// SETTINGS by itself. The stream with stream ID=1 is opened and the
/// |stream_user_data| is used for its stream_user_data. The opened
/// stream becomes half-closed (local) state.
///
/// If called from server side, the |settings_payload| must be the
/// value received in ``HTTP2-Settings`` header field and must be
/// decoded by base64url decoder. The |settings_payloadlen| is the
/// length of |settings_payload|. It is treated as if the SETTINGS
/// frame with that payload is received. Thus, callback functions for
/// the reception of SETTINGS frame will be invoked. The stream with
/// stream ID=1 is opened. The |stream_user_data| is ignored. The
/// opened stream becomes half-closed (remote).
///
/// If the request method is HEAD, pass nonzero value to
/// |head_request|. Otherwise, pass 0.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |settings_payload| is badly formed.
/// :enum:`NGHTTP2_ERR_PROTO`
/// The stream ID 1 is already used or closed; or is not available.
pub fn nghttp2_session_upgrade2(
session: *mut nghttp2_session,
settings_payload: *const u8,
settings_payloadlen: usize,
head_request: ::std::os::raw::c_int,
stream_user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Serializes the SETTINGS values |iv| in the |buf|. The size of the
/// |buf| is specified by |buflen|. The number of entries in the |iv|
/// array is given by |niv|. The required space in |buf| for the |niv|
/// entries is ``6*niv`` bytes and if the given buffer is too small, an
/// error is returned. This function is used mainly for creating a
/// SETTINGS payload to be sent with the ``HTTP2-Settings`` header
/// field in an HTTP Upgrade request. The data written in |buf| is NOT
/// base64url encoded and the application is responsible for encoding.
///
/// This function returns the number of bytes written in |buf|, or one
/// of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |iv| contains duplicate settings ID or invalid value.
///
/// :enum:`NGHTTP2_ERR_INSUFF_BUFSIZE`
/// The provided |buflen| size is too small to hold the output.
pub fn nghttp2_pack_settings_payload(
buf: *mut u8,
buflen: usize,
iv: *const nghttp2_settings_entry,
niv: usize,
) -> isize;
}
extern "C" {
/// @function
///
/// Returns string describing the |lib_error_code|. The
/// |lib_error_code| must be one of the :enum:`nghttp2_error`.
pub fn nghttp2_strerror(lib_error_code: ::std::os::raw::c_int)
-> *const ::std::os::raw::c_char;
}
extern "C" {
/// @function
///
/// Returns string representation of HTTP/2 error code |error_code|
/// (e.g., ``PROTOCOL_ERROR`` is returned if ``error_code ==
/// NGHTTP2_PROTOCOL_ERROR``). If string representation is unknown for
/// given |error_code|, this function returns string ``unknown``.
pub fn nghttp2_http2_strerror(error_code: u32) -> *const ::std::os::raw::c_char;
}
extern "C" {
/// @function
///
/// Initializes |pri_spec| with the |stream_id| of the stream to depend
/// on with |weight| and its exclusive flag. If |exclusive| is
/// nonzero, exclusive flag is set.
///
/// The |weight| must be in [:enum:`NGHTTP2_MIN_WEIGHT`,
/// :enum:`NGHTTP2_MAX_WEIGHT`], inclusive.
pub fn nghttp2_priority_spec_init(
pri_spec: *mut nghttp2_priority_spec,
stream_id: i32,
weight: i32,
exclusive: ::std::os::raw::c_int,
);
}
extern "C" {
/// @function
///
/// Initializes |pri_spec| with the default values. The default values
/// are: stream_id = 0, weight = :macro:`NGHTTP2_DEFAULT_WEIGHT` and
/// exclusive = 0.
pub fn nghttp2_priority_spec_default_init(pri_spec: *mut nghttp2_priority_spec);
}
extern "C" {
/// @function
///
/// Returns nonzero if the |pri_spec| is filled with default values.
pub fn nghttp2_priority_spec_check_default(
pri_spec: *const nghttp2_priority_spec,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits HEADERS frame and optionally one or more DATA frames.
///
/// The |pri_spec| is priority specification of this request. ``NULL``
/// means the default priority (see
/// `nghttp2_priority_spec_default_init()`). To specify the priority,
/// use `nghttp2_priority_spec_init()`. If |pri_spec| is not ``NULL``,
/// this function will copy its data members.
///
/// The ``pri_spec->weight`` must be in [:enum:`NGHTTP2_MIN_WEIGHT`,
/// :enum:`NGHTTP2_MAX_WEIGHT`], inclusive. If ``pri_spec->weight`` is
/// strictly less than :enum:`NGHTTP2_MIN_WEIGHT`, it becomes
/// :enum:`NGHTTP2_MIN_WEIGHT`. If it is strictly greater than
/// :enum:`NGHTTP2_MAX_WEIGHT`, it becomes :enum:`NGHTTP2_MAX_WEIGHT`.
///
/// The |nva| is an array of name/value pair :type:`nghttp2_nv` with
/// |nvlen| elements. The application is responsible to include
/// required pseudo-header fields (header field whose name starts with
/// ":") in |nva| and must place pseudo-headers before regular header
/// fields.
///
/// This function creates copies of all name/value pairs in |nva|. It
/// also lower-cases all names in |nva|. The order of elements in
/// |nva| is preserved. For header fields with
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME` and
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set, header field name
/// and value are not copied respectively. With
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`, application is responsible to
/// pass header field name in lowercase. The application should
/// maintain the references to them until
/// :type:`nghttp2_on_frame_send_callback` or
/// :type:`nghttp2_on_frame_not_send_callback` is called.
///
/// HTTP/2 specification has requirement about header fields in the
/// request HEADERS. See the specification for more details.
///
/// If |data_prd| is not ``NULL``, it provides data which will be sent
/// in subsequent DATA frames. In this case, a method that allows
/// request message bodies
/// (https://tools.ietf.org/html/rfc7231#section-4) must be specified
/// with ``:method`` key in |nva| (e.g. ``POST``). This function does
/// not take ownership of the |data_prd|. The function copies the
/// members of the |data_prd|. If |data_prd| is ``NULL``, HEADERS have
/// END_STREAM set. The |stream_user_data| is data associated to the
/// stream opened by this request and can be an arbitrary pointer,
/// which can be retrieved later by
/// `nghttp2_session_get_stream_user_data()`.
///
/// This function returns assigned stream ID if it succeeds, or one of
/// the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`
/// No stream ID is available because maximum stream ID was
/// reached.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// Trying to depend on itself (new stream ID equals
/// ``pri_spec->stream_id``).
/// :enum:`NGHTTP2_ERR_PROTO`
/// The |session| is server session.
///
/// .. warning::
///
/// This function returns assigned stream ID if it succeeds. But
/// that stream is not created yet. The application must not submit
/// frame to that stream ID before
/// :type:`nghttp2_before_frame_send_callback` is called for this
/// frame. This means `nghttp2_session_get_stream_user_data()` does
/// not work before the callback. But
/// `nghttp2_session_set_stream_user_data()` handles this situation
/// specially, and it can set data to a stream during this period.
///
pub fn nghttp2_submit_request(
session: *mut nghttp2_session,
pri_spec: *const nghttp2_priority_spec,
nva: *const nghttp2_nv,
nvlen: usize,
data_prd: *const nghttp2_data_provider,
stream_user_data: *mut ::std::os::raw::c_void,
) -> i32;
}
extern "C" {
/// @function
///
/// Submits response HEADERS frame and optionally one or more DATA
/// frames against the stream |stream_id|.
///
/// The |nva| is an array of name/value pair :type:`nghttp2_nv` with
/// |nvlen| elements. The application is responsible to include
/// required pseudo-header fields (header field whose name starts with
/// ":") in |nva| and must place pseudo-headers before regular header
/// fields.
///
/// This function creates copies of all name/value pairs in |nva|. It
/// also lower-cases all names in |nva|. The order of elements in
/// |nva| is preserved. For header fields with
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME` and
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set, header field name
/// and value are not copied respectively. With
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`, application is responsible to
/// pass header field name in lowercase. The application should
/// maintain the references to them until
/// :type:`nghttp2_on_frame_send_callback` or
/// :type:`nghttp2_on_frame_not_send_callback` is called.
///
/// HTTP/2 specification has requirement about header fields in the
/// response HEADERS. See the specification for more details.
///
/// If |data_prd| is not ``NULL``, it provides data which will be sent
/// in subsequent DATA frames. This function does not take ownership
/// of the |data_prd|. The function copies the members of the
/// |data_prd|. If |data_prd| is ``NULL``, HEADERS will have
/// END_STREAM flag set.
///
/// This method can be used as normal HTTP response and push response.
/// When pushing a resource using this function, the |session| must be
/// configured using `nghttp2_session_server_new()` or its variants and
/// the target stream denoted by the |stream_id| must be reserved using
/// `nghttp2_submit_push_promise()`.
///
/// To send non-final response headers (e.g., HTTP status 101), don't
/// use this function because this function half-closes the outbound
/// stream. Instead, use `nghttp2_submit_headers()` for this purpose.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
/// :enum:`NGHTTP2_ERR_DATA_EXIST`
/// DATA or HEADERS has been already submitted and not fully
/// processed yet. Normally, this does not happen, but when
/// application wrongly calls `nghttp2_submit_response()` twice,
/// this may happen.
/// :enum:`NGHTTP2_ERR_PROTO`
/// The |session| is client session.
///
/// .. warning::
///
/// Calling this function twice for the same stream ID may lead to
/// program crash. It is generally considered to a programming error
/// to commit response twice.
pub fn nghttp2_submit_response(
session: *mut nghttp2_session,
stream_id: i32,
nva: *const nghttp2_nv,
nvlen: usize,
data_prd: *const nghttp2_data_provider,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits trailer fields HEADERS against the stream |stream_id|.
///
/// The |nva| is an array of name/value pair :type:`nghttp2_nv` with
/// |nvlen| elements. The application must not include pseudo-header
/// fields (headers whose names starts with ":") in |nva|.
///
/// This function creates copies of all name/value pairs in |nva|. It
/// also lower-cases all names in |nva|. The order of elements in
/// |nva| is preserved. For header fields with
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME` and
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set, header field name
/// and value are not copied respectively. With
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`, application is responsible to
/// pass header field name in lowercase. The application should
/// maintain the references to them until
/// :type:`nghttp2_on_frame_send_callback` or
/// :type:`nghttp2_on_frame_not_send_callback` is called.
///
/// For server, trailer fields must follow response HEADERS or response
/// DATA without END_STREAM flat set. The library does not enforce
/// this requirement, and applications should do this for themselves.
/// If `nghttp2_submit_trailer()` is called before any response HEADERS
/// submission (usually by `nghttp2_submit_response()`), the content of
/// |nva| will be sent as response headers, which will result in error.
///
/// This function has the same effect with `nghttp2_submit_headers()`,
/// with flags = :enum:`NGHTTP2_FLAG_END_STREAM` and both pri_spec and
/// stream_user_data to NULL.
///
/// To submit trailer fields after `nghttp2_submit_response()` is
/// called, the application has to specify
/// :type:`nghttp2_data_provider` to `nghttp2_submit_response()`.
/// Inside of :type:`nghttp2_data_source_read_callback`, when setting
/// :enum:`NGHTTP2_DATA_FLAG_EOF`, also set
/// :enum:`NGHTTP2_DATA_FLAG_NO_END_STREAM`. After that, the
/// application can send trailer fields using
/// `nghttp2_submit_trailer()`. `nghttp2_submit_trailer()` can be used
/// inside :type:`nghttp2_data_source_read_callback`.
///
/// This function returns 0 if it succeeds and |stream_id| is -1.
/// Otherwise, this function returns 0 if it succeeds, or one of the
/// following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
pub fn nghttp2_submit_trailer(
session: *mut nghttp2_session,
stream_id: i32,
nva: *const nghttp2_nv,
nvlen: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits HEADERS frame. The |flags| is bitwise OR of the
/// following values:
///
/// * :enum:`NGHTTP2_FLAG_END_STREAM`
///
/// If |flags| includes :enum:`NGHTTP2_FLAG_END_STREAM`, this frame has
/// END_STREAM flag set.
///
/// The library handles the CONTINUATION frame internally and it
/// correctly sets END_HEADERS to the last sequence of the PUSH_PROMISE
/// or CONTINUATION frame.
///
/// If the |stream_id| is -1, this frame is assumed as request (i.e.,
/// request HEADERS frame which opens new stream). In this case, the
/// assigned stream ID will be returned. Otherwise, specify stream ID
/// in |stream_id|.
///
/// The |pri_spec| is priority specification of this request. ``NULL``
/// means the default priority (see
/// `nghttp2_priority_spec_default_init()`). To specify the priority,
/// use `nghttp2_priority_spec_init()`. If |pri_spec| is not ``NULL``,
/// this function will copy its data members.
///
/// The ``pri_spec->weight`` must be in [:enum:`NGHTTP2_MIN_WEIGHT`,
/// :enum:`NGHTTP2_MAX_WEIGHT`], inclusive. If ``pri_spec->weight`` is
/// strictly less than :enum:`NGHTTP2_MIN_WEIGHT`, it becomes
/// :enum:`NGHTTP2_MIN_WEIGHT`. If it is strictly greater than
/// :enum:`NGHTTP2_MAX_WEIGHT`, it becomes :enum:`NGHTTP2_MAX_WEIGHT`.
///
/// The |nva| is an array of name/value pair :type:`nghttp2_nv` with
/// |nvlen| elements. The application is responsible to include
/// required pseudo-header fields (header field whose name starts with
/// ":") in |nva| and must place pseudo-headers before regular header
/// fields.
///
/// This function creates copies of all name/value pairs in |nva|. It
/// also lower-cases all names in |nva|. The order of elements in
/// |nva| is preserved. For header fields with
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME` and
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set, header field name
/// and value are not copied respectively. With
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`, application is responsible to
/// pass header field name in lowercase. The application should
/// maintain the references to them until
/// :type:`nghttp2_on_frame_send_callback` or
/// :type:`nghttp2_on_frame_not_send_callback` is called.
///
/// The |stream_user_data| is a pointer to an arbitrary data which is
/// associated to the stream this frame will open. Therefore it is
/// only used if this frame opens streams, in other words, it changes
/// stream state from idle or reserved to open.
///
/// This function is low-level in a sense that the application code can
/// specify flags directly. For usual HTTP request,
/// `nghttp2_submit_request()` is useful. Likewise, for HTTP response,
/// prefer `nghttp2_submit_response()`.
///
/// This function returns newly assigned stream ID if it succeeds and
/// |stream_id| is -1. Otherwise, this function returns 0 if it
/// succeeds, or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`
/// No stream ID is available because maximum stream ID was
/// reached.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0; or trying to depend on itself (stream ID
/// equals ``pri_spec->stream_id``).
/// :enum:`NGHTTP2_ERR_DATA_EXIST`
/// DATA or HEADERS has been already submitted and not fully
/// processed yet. This happens if stream denoted by |stream_id|
/// is in reserved state.
/// :enum:`NGHTTP2_ERR_PROTO`
/// The |stream_id| is -1, and |session| is server session.
///
/// .. warning::
///
/// This function returns assigned stream ID if it succeeds and
/// |stream_id| is -1. But that stream is not opened yet. The
/// application must not submit frame to that stream ID before
/// :type:`nghttp2_before_frame_send_callback` is called for this
/// frame.
///
pub fn nghttp2_submit_headers(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
pri_spec: *const nghttp2_priority_spec,
nva: *const nghttp2_nv,
nvlen: usize,
stream_user_data: *mut ::std::os::raw::c_void,
) -> i32;
}
extern "C" {
/// @function
///
/// Submits one or more DATA frames to the stream |stream_id|. The
/// data to be sent are provided by |data_prd|. If |flags| contains
/// :enum:`NGHTTP2_FLAG_END_STREAM`, the last DATA frame has END_STREAM
/// flag set.
///
/// This function does not take ownership of the |data_prd|. The
/// function copies the members of the |data_prd|.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_DATA_EXIST`
/// DATA or HEADERS has been already submitted and not fully
/// processed yet.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
/// :enum:`NGHTTP2_ERR_STREAM_CLOSED`
/// The stream was already closed; or the |stream_id| is invalid.
///
/// .. note::
///
/// Currently, only one DATA or HEADERS is allowed for a stream at a
/// time. Submitting these frames more than once before first DATA
/// or HEADERS is finished results in :enum:`NGHTTP2_ERR_DATA_EXIST`
/// error code. The earliest callback which tells that previous
/// frame is done is :type:`nghttp2_on_frame_send_callback`. In side
/// that callback, new data can be submitted using
/// `nghttp2_submit_data()`. Of course, all data except for last one
/// must not have :enum:`NGHTTP2_FLAG_END_STREAM` flag set in
/// |flags|. This sounds a bit complicated, and we recommend to use
/// `nghttp2_submit_request()` and `nghttp2_submit_response()` to
/// avoid this cascading issue. The experience shows that for HTTP
/// use, these two functions are enough to implement both client and
/// server.
pub fn nghttp2_submit_data(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
data_prd: *const nghttp2_data_provider,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits PRIORITY frame to change the priority of stream |stream_id|
/// to the priority specification |pri_spec|.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// The |pri_spec| is priority specification of this request. ``NULL``
/// is not allowed for this function. To specify the priority, use
/// `nghttp2_priority_spec_init()`. This function will copy its data
/// members.
///
/// The ``pri_spec->weight`` must be in [:enum:`NGHTTP2_MIN_WEIGHT`,
/// :enum:`NGHTTP2_MAX_WEIGHT`], inclusive. If ``pri_spec->weight`` is
/// strictly less than :enum:`NGHTTP2_MIN_WEIGHT`, it becomes
/// :enum:`NGHTTP2_MIN_WEIGHT`. If it is strictly greater than
/// :enum:`NGHTTP2_MAX_WEIGHT`, it becomes :enum:`NGHTTP2_MAX_WEIGHT`.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0; or the |pri_spec| is NULL; or trying to
/// depend on itself.
pub fn nghttp2_submit_priority(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
pri_spec: *const nghttp2_priority_spec,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits RST_STREAM frame to cancel/reject the stream |stream_id|
/// with the error code |error_code|.
///
/// The pre-defined error code is one of :enum:`nghttp2_error_code`.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0.
pub fn nghttp2_submit_rst_stream(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
error_code: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Stores local settings and submits SETTINGS frame. The |iv| is the
/// pointer to the array of :type:`nghttp2_settings_entry`. The |niv|
/// indicates the number of :type:`nghttp2_settings_entry`.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// This function does not take ownership of the |iv|. This function
/// copies all the elements in the |iv|.
///
/// While updating individual stream's local window size, if the window
/// size becomes strictly larger than NGHTTP2_MAX_WINDOW_SIZE,
/// RST_STREAM is issued against such a stream.
///
/// SETTINGS with :enum:`NGHTTP2_FLAG_ACK` is automatically submitted
/// by the library and application could not send it at its will.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |iv| contains invalid value (e.g., initial window size
/// strictly greater than (1 << 31) - 1.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_submit_settings(
session: *mut nghttp2_session,
flags: u8,
iv: *const nghttp2_settings_entry,
niv: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits PUSH_PROMISE frame.
///
/// The |flags| is currently ignored. The library handles the
/// CONTINUATION frame internally and it correctly sets END_HEADERS to
/// the last sequence of the PUSH_PROMISE or CONTINUATION frame.
///
/// The |stream_id| must be client initiated stream ID.
///
/// The |nva| is an array of name/value pair :type:`nghttp2_nv` with
/// |nvlen| elements. The application is responsible to include
/// required pseudo-header fields (header field whose name starts with
/// ":") in |nva| and must place pseudo-headers before regular header
/// fields.
///
/// This function creates copies of all name/value pairs in |nva|. It
/// also lower-cases all names in |nva|. The order of elements in
/// |nva| is preserved. For header fields with
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME` and
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set, header field name
/// and value are not copied respectively. With
/// :enum:`NGHTTP2_NV_FLAG_NO_COPY_NAME`, application is responsible to
/// pass header field name in lowercase. The application should
/// maintain the references to them until
/// :type:`nghttp2_on_frame_send_callback` or
/// :type:`nghttp2_on_frame_not_send_callback` is called.
///
/// The |promised_stream_user_data| is a pointer to an arbitrary data
/// which is associated to the promised stream this frame will open and
/// make it in reserved state. It is available using
/// `nghttp2_session_get_stream_user_data()`. The application can
/// access it in :type:`nghttp2_before_frame_send_callback` and
/// :type:`nghttp2_on_frame_send_callback` of this frame.
///
/// The client side is not allowed to use this function.
///
/// To submit response headers and data, use
/// `nghttp2_submit_response()`.
///
/// This function returns assigned promised stream ID if it succeeds,
/// or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_PROTO`
/// This function was invoked when |session| is initialized as
/// client.
/// :enum:`NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`
/// No stream ID is available because maximum stream ID was
/// reached.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is 0; The |stream_id| does not designate stream
/// that peer initiated.
/// :enum:`NGHTTP2_ERR_STREAM_CLOSED`
/// The stream was already closed; or the |stream_id| is invalid.
///
/// .. warning::
///
/// This function returns assigned promised stream ID if it succeeds.
/// As of 1.16.0, stream object for pushed resource is created when
/// this function succeeds. In that case, the application can submit
/// push response for the promised frame.
///
/// In 1.15.0 or prior versions, pushed stream is not opened yet when
/// this function succeeds. The application must not submit frame to
/// that stream ID before :type:`nghttp2_before_frame_send_callback`
/// is called for this frame.
///
pub fn nghttp2_submit_push_promise(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
nva: *const nghttp2_nv,
nvlen: usize,
promised_stream_user_data: *mut ::std::os::raw::c_void,
) -> i32;
}
extern "C" {
/// @function
///
/// Submits PING frame. You don't have to send PING back when you
/// received PING frame. The library automatically submits PING frame
/// in this case.
///
/// The |flags| is bitwise OR of 0 or more of the following value.
///
/// * :enum:`NGHTTP2_FLAG_ACK`
///
/// Unless `nghttp2_option_set_no_auto_ping_ack()` is used, the |flags|
/// should be :enum:`NGHTTP2_FLAG_NONE`.
///
/// If the |opaque_data| is non ``NULL``, then it should point to the 8
/// bytes array of memory to specify opaque data to send with PING
/// frame. If the |opaque_data| is ``NULL``, zero-cleared 8 bytes will
/// be sent as opaque data.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_submit_ping(
session: *mut nghttp2_session,
flags: u8,
opaque_data: *const u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits GOAWAY frame with the last stream ID |last_stream_id| and
/// the error code |error_code|.
///
/// The pre-defined error code is one of :enum:`nghttp2_error_code`.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// The |last_stream_id| is peer's stream ID or 0. So if |session| is
/// initialized as client, |last_stream_id| must be even or 0. If
/// |session| is initialized as server, |last_stream_id| must be odd or
/// 0.
///
/// The HTTP/2 specification says last_stream_id must not be increased
/// from the value previously sent. So the actual value sent as
/// last_stream_id is the minimum value between the given
/// |last_stream_id| and the last_stream_id previously sent to the
/// peer.
///
/// If the |opaque_data| is not ``NULL`` and |opaque_data_len| is not
/// zero, those data will be sent as additional debug data. The
/// library makes a copy of the memory region pointed by |opaque_data|
/// with the length |opaque_data_len|, so the caller does not need to
/// keep this memory after the return of this function. If the
/// |opaque_data_len| is 0, the |opaque_data| could be ``NULL``.
///
/// After successful transmission of GOAWAY, following things happen.
/// All incoming streams having strictly more than |last_stream_id| are
/// closed. All incoming HEADERS which starts new stream are simply
/// ignored. After all active streams are handled, both
/// `nghttp2_session_want_read()` and `nghttp2_session_want_write()`
/// return 0 and the application can close session.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |opaque_data_len| is too large; the |last_stream_id| is
/// invalid.
pub fn nghttp2_submit_goaway(
session: *mut nghttp2_session,
flags: u8,
last_stream_id: i32,
error_code: u32,
opaque_data: *const u8,
opaque_data_len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the last stream ID of a stream for which
/// :type:`nghttp2_on_frame_recv_callback` was invoked most recently.
/// The returned value can be used as last_stream_id parameter for
/// `nghttp2_submit_goaway()` and
/// `nghttp2_session_terminate_session2()`.
///
/// This function always succeeds.
pub fn nghttp2_session_get_last_proc_stream_id(session: *mut nghttp2_session) -> i32;
}
extern "C" {
/// @function
///
/// Returns nonzero if new request can be sent from local endpoint.
///
/// This function return 0 if request is not allowed for this session.
/// There are several reasons why request is not allowed. Some of the
/// reasons are: session is server; stream ID has been spent; GOAWAY
/// has been sent or received.
///
/// The application can call `nghttp2_submit_request()` without
/// consulting this function. In that case, `nghttp2_submit_request()`
/// may return error. Or, request is failed to sent, and
/// :type:`nghttp2_on_stream_close_callback` is called.
pub fn nghttp2_session_check_request_allowed(
session: *mut nghttp2_session,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns nonzero if |session| is initialized as server side session.
pub fn nghttp2_session_check_server_session(
session: *mut nghttp2_session,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits WINDOW_UPDATE frame.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// The |stream_id| is the stream ID to send this WINDOW_UPDATE. To
/// send connection level WINDOW_UPDATE, specify 0 to |stream_id|.
///
/// If the |window_size_increment| is positive, the WINDOW_UPDATE with
/// that value as window_size_increment is queued. If the
/// |window_size_increment| is larger than the received bytes from the
/// remote endpoint, the local window size is increased by that
/// difference. If the sole purpose is to increase the local window
/// size, consider to use `nghttp2_session_set_local_window_size()`.
///
/// If the |window_size_increment| is negative, the local window size
/// is decreased by -|window_size_increment|. If automatic
/// WINDOW_UPDATE is enabled
/// (`nghttp2_option_set_no_auto_window_update()`), and the library
/// decided that the WINDOW_UPDATE should be submitted, then
/// WINDOW_UPDATE is queued with the current received bytes count. If
/// the sole purpose is to decrease the local window size, consider to
/// use `nghttp2_session_set_local_window_size()`.
///
/// If the |window_size_increment| is 0, the function does nothing and
/// returns 0.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_FLOW_CONTROL`
/// The local window size overflow or gets negative.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_submit_window_update(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
window_size_increment: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Set local window size (local endpoints's window size) to the given
/// |window_size| for the given stream denoted by |stream_id|. To
/// change connection level window size, specify 0 to |stream_id|. To
/// increase window size, this function may submit WINDOW_UPDATE frame
/// to transmission queue.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// This sounds similar to `nghttp2_submit_window_update()`, but there
/// are 2 differences. The first difference is that this function
/// takes the absolute value of window size to set, rather than the
/// delta. To change the window size, this may be easier to use since
/// the application just declares the intended window size, rather than
/// calculating delta. The second difference is that
/// `nghttp2_submit_window_update()` affects the received bytes count
/// which has not acked yet. By the specification of
/// `nghttp2_submit_window_update()`, to strictly increase the local
/// window size, we have to submit delta including all received bytes
/// count, which might not be desirable in some cases. On the other
/// hand, this function does not affect the received bytes count. It
/// just sets the local window size to the given value.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The |stream_id| is negative.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_session_set_local_window_size(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
window_size: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Submits extension frame.
///
/// Application can pass arbitrary frame flags and stream ID in |flags|
/// and |stream_id| respectively. The |payload| is opaque pointer, and
/// it can be accessible though ``frame->ext.payload`` in
/// :type:`nghttp2_pack_extension_callback`. The library will not own
/// passed |payload| pointer.
///
/// The application must set :type:`nghttp2_pack_extension_callback`
/// using `nghttp2_session_callbacks_set_pack_extension_callback()`.
///
/// The application should retain the memory pointed by |payload| until
/// the transmission of extension frame is done (which is indicated by
/// :type:`nghttp2_on_frame_send_callback`), or transmission fails
/// (which is indicated by :type:`nghttp2_on_frame_not_send_callback`).
/// If application does not touch this memory region after packing it
/// into a wire format, application can free it inside
/// :type:`nghttp2_pack_extension_callback`.
///
/// The standard HTTP/2 frame cannot be sent with this function, so
/// |type| must be strictly grater than 0x9. Otherwise, this function
/// will fail with error code :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// If :type:`nghttp2_pack_extension_callback` is not set.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// If |type| specifies standard HTTP/2 frame type. The frame
/// types in the rage [0x0, 0x9], both inclusive, are standard
/// HTTP/2 frame type, and cannot be sent using this function.
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory
pub fn nghttp2_submit_extension(
session: *mut nghttp2_session,
type_: u8,
flags: u8,
stream_id: i32,
payload: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
/// @struct
///
/// The payload of ALTSVC frame. ALTSVC frame is a non-critical
/// extension to HTTP/2. If this frame is received, and
/// `nghttp2_option_set_user_recv_extension_type()` is not set, and
/// `nghttp2_option_set_builtin_recv_extension_type()` is set for
/// :enum:`NGHTTP2_ALTSVC`, ``nghttp2_extension.payload`` will point to
/// this struct.
///
/// It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_ext_altsvc {
/// The pointer to origin which this alternative service is
/// associated with. This is not necessarily NULL-terminated.
pub origin: *mut u8,
/// The length of the |origin|.
pub origin_len: usize,
/// The pointer to Alt-Svc field value contained in ALTSVC frame.
/// This is not necessarily NULL-terminated.
pub field_value: *mut u8,
/// The length of the |field_value|.
pub field_value_len: usize,
}
extern "C" {
/// @function
///
/// Submits ALTSVC frame.
///
/// ALTSVC frame is a non-critical extension to HTTP/2, and defined in
/// `RFC 7383 <https://tools.ietf.org/html/rfc7838#section-4>`_.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// The |origin| points to the origin this alternative service is
/// associated with. The |origin_len| is the length of the origin. If
/// |stream_id| is 0, the origin must be specified. If |stream_id| is
/// not zero, the origin must be empty (in other words, |origin_len|
/// must be 0).
///
/// The ALTSVC frame is only usable from server side. If this function
/// is invoked with client side session, this function returns
/// :enum:`NGHTTP2_ERR_INVALID_STATE`.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// The function is called from client side session
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// The sum of |origin_len| and |field_value_len| is larger than
/// 16382; or |origin_len| is 0 while |stream_id| is 0; or
/// |origin_len| is not 0 while |stream_id| is not 0.
pub fn nghttp2_submit_altsvc(
session: *mut nghttp2_session,
flags: u8,
stream_id: i32,
origin: *const u8,
origin_len: usize,
field_value: *const u8,
field_value_len: usize,
) -> ::std::os::raw::c_int;
}
/// @struct
///
/// The single entry of an origin.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_origin_entry {
/// The pointer to origin. No validation is made against this field
/// by the library. This is not necessarily NULL-terminated.
pub origin: *mut u8,
/// The length of the |origin|.
pub origin_len: usize,
}
/// @struct
///
/// The payload of ORIGIN frame. ORIGIN frame is a non-critical
/// extension to HTTP/2 and defined by `RFC 8336
/// <https://tools.ietf.org/html/rfc8336>`_.
///
/// If this frame is received, and
/// `nghttp2_option_set_user_recv_extension_type()` is not set, and
/// `nghttp2_option_set_builtin_recv_extension_type()` is set for
/// :enum:`NGHTTP2_ORIGIN`, ``nghttp2_extension.payload`` will point to
/// this struct.
///
/// It has the following members:
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_ext_origin {
/// The number of origins contained in |ov|.
pub nov: usize,
/// The pointer to the array of origins contained in ORIGIN frame.
pub ov: *mut nghttp2_origin_entry,
}
extern "C" {
/// @function
///
/// Submits ORIGIN frame.
///
/// ORIGIN frame is a non-critical extension to HTTP/2 and defined by
/// `RFC 8336 <https://tools.ietf.org/html/rfc8336>`_.
///
/// The |flags| is currently ignored and should be
/// :enum:`NGHTTP2_FLAG_NONE`.
///
/// The |ov| points to the array of origins. The |nov| specifies the
/// number of origins included in |ov|. This function creates copies
/// of all elements in |ov|.
///
/// The ORIGIN frame is only usable by a server. If this function is
/// invoked with client side session, this function returns
/// :enum:`NGHTTP2_ERR_INVALID_STATE`.
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// The function is called from client side session.
/// :enum:`NGHTTP2_ERR_INVALID_ARGUMENT`
/// There are too many origins, or an origin is too large to fit
/// into a default frame payload.
pub fn nghttp2_submit_origin(
session: *mut nghttp2_session,
flags: u8,
ov: *const nghttp2_origin_entry,
nov: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Compares ``lhs->name`` of length ``lhs->namelen`` bytes and
/// ``rhs->name`` of length ``rhs->namelen`` bytes. Returns negative
/// integer if ``lhs->name`` is found to be less than ``rhs->name``; or
/// returns positive integer if ``lhs->name`` is found to be greater
/// than ``rhs->name``; or returns 0 otherwise.
pub fn nghttp2_nv_compare_name(
lhs: *const nghttp2_nv,
rhs: *const nghttp2_nv,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// A helper function for dealing with NPN in client side or ALPN in
/// server side. The |in| contains peer's protocol list in preferable
/// order. The format of |in| is length-prefixed and not
/// null-terminated. For example, ``h2`` and
/// ``http/1.1`` stored in |in| like this::
///
/// in[0] = 2
/// in[1..2] = "h2"
/// in[3] = 8
/// in[4..11] = "http/1.1"
/// inlen = 12
///
/// The selection algorithm is as follows:
///
/// 1. If peer's list contains HTTP/2 protocol the library supports,
/// it is selected and returns 1. The following step is not taken.
///
/// 2. If peer's list contains ``http/1.1``, this function selects
/// ``http/1.1`` and returns 0. The following step is not taken.
///
/// 3. This function selects nothing and returns -1 (So called
/// non-overlap case). In this case, |out| and |outlen| are left
/// untouched.
///
/// Selecting ``h2`` means that ``h2`` is written into |*out| and its
/// length (which is 2) is assigned to |*outlen|.
///
/// For ALPN, refer to https://tools.ietf.org/html/rfc7301
///
/// See http://technotes.googlecode.com/git/nextprotoneg.html for more
/// details about NPN.
///
/// For NPN, to use this method you should do something like::
///
/// static int select_next_proto_cb(SSL* ssl,
/// unsigned char **out,
/// unsigned char *outlen,
/// const unsigned char *in,
/// unsigned int inlen,
/// void *arg)
/// {
/// int rv;
/// rv = nghttp2_select_next_protocol(out, outlen, in, inlen);
/// if (rv == -1) {
/// return SSL_TLSEXT_ERR_NOACK;
/// }
/// if (rv == 1) {
/// ((MyType*)arg)->http2_selected = 1;
/// }
/// return SSL_TLSEXT_ERR_OK;
/// }
/// ...
/// SSL_CTX_set_next_proto_select_cb(ssl_ctx, select_next_proto_cb, my_obj);
///
pub fn nghttp2_select_next_protocol(
out: *mut *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_uchar,
in_: *const ::std::os::raw::c_uchar,
inlen: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns a pointer to a nghttp2_info struct with version information
/// about the run-time library in use. The |least_version| argument
/// can be set to a 24 bit numerical value for the least accepted
/// version number and if the condition is not met, this function will
/// return a ``NULL``. Pass in 0 to skip the version checking.
pub fn nghttp2_version(least_version: ::std::os::raw::c_int) -> *mut nghttp2_info;
}
extern "C" {
/// @function
///
/// Returns nonzero if the :type:`nghttp2_error` library error code
/// |lib_error| is fatal.
pub fn nghttp2_is_fatal(lib_error_code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns nonzero if HTTP header field name |name| of length |len| is
/// valid according to http://tools.ietf.org/html/rfc7230#section-3.2
///
/// Because this is a header field name in HTTP2, the upper cased alphabet
/// is treated as error.
pub fn nghttp2_check_header_name(name: *const u8, len: usize) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns nonzero if HTTP header field value |value| of length |len|
/// is valid according to
/// http://tools.ietf.org/html/rfc7230#section-3.2
pub fn nghttp2_check_header_value(value: *const u8, len: usize) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_hd_deflater {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Initializes |*deflater_ptr| for deflating name/values pairs.
///
/// The |max_deflate_dynamic_table_size| is the upper bound of header
/// table size the deflater will use.
///
/// If this function fails, |*deflater_ptr| is left untouched.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_hd_deflate_new(
deflater_ptr: *mut *mut nghttp2_hd_deflater,
max_deflate_dynamic_table_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_hd_deflate_new()`, but with additional custom memory
/// allocator specified in the |mem|.
///
/// The |mem| can be ``NULL`` and the call is equivalent to
/// `nghttp2_hd_deflate_new()`.
///
/// This function does not take ownership |mem|. The application is
/// responsible for freeing |mem|.
///
/// The library code does not refer to |mem| pointer after this
/// function returns, so the application can safely free it.
pub fn nghttp2_hd_deflate_new2(
deflater_ptr: *mut *mut nghttp2_hd_deflater,
max_deflate_dynamic_table_size: usize,
mem: *mut nghttp2_mem,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Deallocates any resources allocated for |deflater|.
pub fn nghttp2_hd_deflate_del(deflater: *mut nghttp2_hd_deflater);
}
extern "C" {
/// @function
///
/// Changes header table size of the |deflater| to
/// |settings_max_dynamic_table_size| bytes. This may trigger eviction
/// in the dynamic table.
///
/// The |settings_max_dynamic_table_size| should be the value received
/// in SETTINGS_HEADER_TABLE_SIZE.
///
/// The deflater never uses more memory than
/// ``max_deflate_dynamic_table_size`` bytes specified in
/// `nghttp2_hd_deflate_new()`. Therefore, if
/// |settings_max_dynamic_table_size| >
/// ``max_deflate_dynamic_table_size``, resulting maximum table size
/// becomes ``max_deflate_dynamic_table_size``.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_hd_deflate_change_table_size(
deflater: *mut nghttp2_hd_deflater,
settings_max_dynamic_table_size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Deflates the |nva|, which has the |nvlen| name/value pairs, into
/// the |buf| of length |buflen|.
///
/// If |buf| is not large enough to store the deflated header block,
/// this function fails with :enum:`NGHTTP2_ERR_INSUFF_BUFSIZE`. The
/// caller should use `nghttp2_hd_deflate_bound()` to know the upper
/// bound of buffer size required to deflate given header name/value
/// pairs.
///
/// Once this function fails, subsequent call of this function always
/// returns :enum:`NGHTTP2_ERR_HEADER_COMP`.
///
/// After this function returns, it is safe to delete the |nva|.
///
/// This function returns the number of bytes written to |buf| if it
/// succeeds, or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_HEADER_COMP`
/// Deflation process has failed.
/// :enum:`NGHTTP2_ERR_INSUFF_BUFSIZE`
/// The provided |buflen| size is too small to hold the output.
pub fn nghttp2_hd_deflate_hd(
deflater: *mut nghttp2_hd_deflater,
buf: *mut u8,
buflen: usize,
nva: *const nghttp2_nv,
nvlen: usize,
) -> isize;
}
extern "C" {
/// @function
///
/// Deflates the |nva|, which has the |nvlen| name/value pairs, into
/// the |veclen| size of buf vector |vec|. The each size of buffer
/// must be set in len field of :type:`nghttp2_vec`. If and only if
/// one chunk is filled up completely, next chunk will be used. If
/// |vec| is not large enough to store the deflated header block, this
/// function fails with :enum:`NGHTTP2_ERR_INSUFF_BUFSIZE`. The caller
/// should use `nghttp2_hd_deflate_bound()` to know the upper bound of
/// buffer size required to deflate given header name/value pairs.
///
/// Once this function fails, subsequent call of this function always
/// returns :enum:`NGHTTP2_ERR_HEADER_COMP`.
///
/// After this function returns, it is safe to delete the |nva|.
///
/// This function returns the number of bytes written to |vec| if it
/// succeeds, or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_HEADER_COMP`
/// Deflation process has failed.
/// :enum:`NGHTTP2_ERR_INSUFF_BUFSIZE`
/// The provided |buflen| size is too small to hold the output.
pub fn nghttp2_hd_deflate_hd_vec(
deflater: *mut nghttp2_hd_deflater,
vec: *const nghttp2_vec,
veclen: usize,
nva: *const nghttp2_nv,
nvlen: usize,
) -> isize;
}
extern "C" {
/// @function
///
/// Returns an upper bound on the compressed size after deflation of
/// |nva| of length |nvlen|.
pub fn nghttp2_hd_deflate_bound(
deflater: *mut nghttp2_hd_deflater,
nva: *const nghttp2_nv,
nvlen: usize,
) -> usize;
}
extern "C" {
/// @function
///
/// Returns the number of entries that header table of |deflater|
/// contains. This is the sum of the number of static table and
/// dynamic table, so the return value is at least 61.
pub fn nghttp2_hd_deflate_get_num_table_entries(deflater: *mut nghttp2_hd_deflater) -> usize;
}
extern "C" {
/// @function
///
/// Returns the table entry denoted by |idx| from header table of
/// |deflater|. The |idx| is 1-based, and idx=1 returns first entry of
/// static table. idx=62 returns first entry of dynamic table if it
/// exists. Specifying idx=0 is error, and this function returns NULL.
/// If |idx| is strictly greater than the number of entries the tables
/// contain, this function returns NULL.
pub fn nghttp2_hd_deflate_get_table_entry(
deflater: *mut nghttp2_hd_deflater,
idx: usize,
) -> *const nghttp2_nv;
}
extern "C" {
/// @function
///
/// Returns the used dynamic table size, including the overhead 32
/// bytes per entry described in RFC 7541.
pub fn nghttp2_hd_deflate_get_dynamic_table_size(deflater: *mut nghttp2_hd_deflater) -> usize;
}
extern "C" {
/// @function
///
/// Returns the maximum dynamic table size.
pub fn nghttp2_hd_deflate_get_max_dynamic_table_size(
deflater: *mut nghttp2_hd_deflater,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_hd_inflater {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Initializes |*inflater_ptr| for inflating name/values pairs.
///
/// If this function fails, |*inflater_ptr| is left untouched.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
pub fn nghttp2_hd_inflate_new(
inflater_ptr: *mut *mut nghttp2_hd_inflater,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Like `nghttp2_hd_inflate_new()`, but with additional custom memory
/// allocator specified in the |mem|.
///
/// The |mem| can be ``NULL`` and the call is equivalent to
/// `nghttp2_hd_inflate_new()`.
///
/// This function does not take ownership |mem|. The application is
/// responsible for freeing |mem|.
///
/// The library code does not refer to |mem| pointer after this
/// function returns, so the application can safely free it.
pub fn nghttp2_hd_inflate_new2(
inflater_ptr: *mut *mut nghttp2_hd_inflater,
mem: *mut nghttp2_mem,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Deallocates any resources allocated for |inflater|.
pub fn nghttp2_hd_inflate_del(inflater: *mut nghttp2_hd_inflater);
}
extern "C" {
/// @function
///
/// Changes header table size in the |inflater|. This may trigger
/// eviction in the dynamic table.
///
/// The |settings_max_dynamic_table_size| should be the value
/// transmitted in SETTINGS_HEADER_TABLE_SIZE.
///
/// This function must not be called while header block is being
/// inflated. In other words, this function must be called after
/// initialization of |inflater|, but before calling
/// `nghttp2_hd_inflate_hd2()`, or after
/// `nghttp2_hd_inflate_end_headers()`. Otherwise,
/// `NGHTTP2_ERR_INVALID_STATE` was returned.
///
/// This function returns 0 if it succeeds, or one of the following
/// negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_INVALID_STATE`
/// The function is called while header block is being inflated.
/// Probably, application missed to call
/// `nghttp2_hd_inflate_end_headers()`.
pub fn nghttp2_hd_inflate_change_table_size(
inflater: *mut nghttp2_hd_inflater,
settings_max_dynamic_table_size: usize,
) -> ::std::os::raw::c_int;
}
/// No flag set.
pub const NGHTTP2_HD_INFLATE_NONE: nghttp2_hd_inflate_flag = 0;
/// Indicates all headers were inflated.
pub const NGHTTP2_HD_INFLATE_FINAL: nghttp2_hd_inflate_flag = 1;
/// Indicates a header was emitted.
pub const NGHTTP2_HD_INFLATE_EMIT: nghttp2_hd_inflate_flag = 2;
/// @enum
///
/// The flags for header inflation.
pub type nghttp2_hd_inflate_flag = u32;
extern "C" {
/// @function
///
/// .. warning::
///
/// Deprecated. Use `nghttp2_hd_inflate_hd2()` instead.
///
/// Inflates name/value block stored in |in| with length |inlen|. This
/// function performs decompression. For each successful emission of
/// header name/value pair, :enum:`NGHTTP2_HD_INFLATE_EMIT` is set in
/// |*inflate_flags| and name/value pair is assigned to the |nv_out|
/// and the function returns. The caller must not free the members of
/// |nv_out|.
///
/// The |nv_out| may include pointers to the memory region in the |in|.
/// The caller must retain the |in| while the |nv_out| is used.
///
/// The application should call this function repeatedly until the
/// ``(*inflate_flags) & NGHTTP2_HD_INFLATE_FINAL`` is nonzero and
/// return value is non-negative. This means the all input values are
/// processed successfully. Then the application must call
/// `nghttp2_hd_inflate_end_headers()` to prepare for the next header
/// block input.
///
/// The caller can feed complete compressed header block. It also can
/// feed it in several chunks. The caller must set |in_final| to
/// nonzero if the given input is the last block of the compressed
/// header.
///
/// This function returns the number of bytes processed if it succeeds,
/// or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_HEADER_COMP`
/// Inflation process has failed.
/// :enum:`NGHTTP2_ERR_BUFFER_ERROR`
/// The header field name or value is too large.
///
/// Example follows::
///
/// int inflate_header_block(nghttp2_hd_inflater *hd_inflater,
/// uint8_t *in, size_t inlen, int final)
/// {
/// ssize_t rv;
///
/// for(;;) {
/// nghttp2_nv nv;
/// int inflate_flags = 0;
///
/// rv = nghttp2_hd_inflate_hd(hd_inflater, &nv, &inflate_flags,
/// in, inlen, final);
///
/// if(rv < 0) {
/// fprintf(stderr, "inflate failed with error code %zd", rv);
/// return -1;
/// }
///
/// in += rv;
/// inlen -= rv;
///
/// if(inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {
/// fwrite(nv.name, nv.namelen, 1, stderr);
/// fprintf(stderr, ": ");
/// fwrite(nv.value, nv.valuelen, 1, stderr);
/// fprintf(stderr, "\n");
/// }
/// if(inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {
/// nghttp2_hd_inflate_end_headers(hd_inflater);
/// break;
/// }
/// if((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 &&
/// inlen == 0) {
/// break;
/// }
/// }
///
/// return 0;
/// }
///
pub fn nghttp2_hd_inflate_hd(
inflater: *mut nghttp2_hd_inflater,
nv_out: *mut nghttp2_nv,
inflate_flags: *mut ::std::os::raw::c_int,
in_: *mut u8,
inlen: usize,
in_final: ::std::os::raw::c_int,
) -> isize;
}
extern "C" {
/// @function
///
/// Inflates name/value block stored in |in| with length |inlen|. This
/// function performs decompression. For each successful emission of
/// header name/value pair, :enum:`NGHTTP2_HD_INFLATE_EMIT` is set in
/// |*inflate_flags| and name/value pair is assigned to the |nv_out|
/// and the function returns. The caller must not free the members of
/// |nv_out|.
///
/// The |nv_out| may include pointers to the memory region in the |in|.
/// The caller must retain the |in| while the |nv_out| is used.
///
/// The application should call this function repeatedly until the
/// ``(*inflate_flags) & NGHTTP2_HD_INFLATE_FINAL`` is nonzero and
/// return value is non-negative. If that happens, all given input
/// data (|inlen| bytes) are processed successfully. Then the
/// application must call `nghttp2_hd_inflate_end_headers()` to prepare
/// for the next header block input.
///
/// In other words, if |in_final| is nonzero, and this function returns
/// |inlen|, you can assert that :enum:`NGHTTP2_HD_INFLATE_FINAL` is
/// set in |*inflate_flags|.
///
/// The caller can feed complete compressed header block. It also can
/// feed it in several chunks. The caller must set |in_final| to
/// nonzero if the given input is the last block of the compressed
/// header.
///
/// This function returns the number of bytes processed if it succeeds,
/// or one of the following negative error codes:
///
/// :enum:`NGHTTP2_ERR_NOMEM`
/// Out of memory.
/// :enum:`NGHTTP2_ERR_HEADER_COMP`
/// Inflation process has failed.
/// :enum:`NGHTTP2_ERR_BUFFER_ERROR`
/// The header field name or value is too large.
///
/// Example follows::
///
/// int inflate_header_block(nghttp2_hd_inflater *hd_inflater,
/// uint8_t *in, size_t inlen, int final)
/// {
/// ssize_t rv;
///
/// for(;;) {
/// nghttp2_nv nv;
/// int inflate_flags = 0;
///
/// rv = nghttp2_hd_inflate_hd2(hd_inflater, &nv, &inflate_flags,
/// in, inlen, final);
///
/// if(rv < 0) {
/// fprintf(stderr, "inflate failed with error code %zd", rv);
/// return -1;
/// }
///
/// in += rv;
/// inlen -= rv;
///
/// if(inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {
/// fwrite(nv.name, nv.namelen, 1, stderr);
/// fprintf(stderr, ": ");
/// fwrite(nv.value, nv.valuelen, 1, stderr);
/// fprintf(stderr, "\n");
/// }
/// if(inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {
/// nghttp2_hd_inflate_end_headers(hd_inflater);
/// break;
/// }
/// if((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 &&
/// inlen == 0) {
/// break;
/// }
/// }
///
/// return 0;
/// }
///
pub fn nghttp2_hd_inflate_hd2(
inflater: *mut nghttp2_hd_inflater,
nv_out: *mut nghttp2_nv,
inflate_flags: *mut ::std::os::raw::c_int,
in_: *const u8,
inlen: usize,
in_final: ::std::os::raw::c_int,
) -> isize;
}
extern "C" {
/// @function
///
/// Signals the end of decompression for one header block.
///
/// This function returns 0 if it succeeds. Currently this function
/// always succeeds.
pub fn nghttp2_hd_inflate_end_headers(
inflater: *mut nghttp2_hd_inflater,
) -> ::std::os::raw::c_int;
}
extern "C" {
/// @function
///
/// Returns the number of entries that header table of |inflater|
/// contains. This is the sum of the number of static table and
/// dynamic table, so the return value is at least 61.
pub fn nghttp2_hd_inflate_get_num_table_entries(inflater: *mut nghttp2_hd_inflater) -> usize;
}
extern "C" {
/// @function
///
/// Returns the table entry denoted by |idx| from header table of
/// |inflater|. The |idx| is 1-based, and idx=1 returns first entry of
/// static table. idx=62 returns first entry of dynamic table if it
/// exists. Specifying idx=0 is error, and this function returns NULL.
/// If |idx| is strictly greater than the number of entries the tables
/// contain, this function returns NULL.
pub fn nghttp2_hd_inflate_get_table_entry(
inflater: *mut nghttp2_hd_inflater,
idx: usize,
) -> *const nghttp2_nv;
}
extern "C" {
/// @function
///
/// Returns the used dynamic table size, including the overhead 32
/// bytes per entry described in RFC 7541.
pub fn nghttp2_hd_inflate_get_dynamic_table_size(inflater: *mut nghttp2_hd_inflater) -> usize;
}
extern "C" {
/// @function
///
/// Returns the maximum dynamic table size.
pub fn nghttp2_hd_inflate_get_max_dynamic_table_size(
inflater: *mut nghttp2_hd_inflater,
) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nghttp2_stream {
_unused: [u8; 0],
}
extern "C" {
/// @function
///
/// Returns pointer to :type:`nghttp2_stream` object denoted by
/// |stream_id|. If stream was not found, returns NULL.
///
/// Returns imaginary root stream (see
/// `nghttp2_session_get_root_stream()`) if 0 is given in |stream_id|.
///
/// Unless |stream_id| == 0, the returned pointer is valid until next
/// call of `nghttp2_session_send()`, `nghttp2_session_mem_send()`,
/// `nghttp2_session_recv()`, and `nghttp2_session_mem_recv()`.
pub fn nghttp2_session_find_stream(
session: *mut nghttp2_session,
stream_id: i32,
) -> *mut nghttp2_stream;
}
/// idle state.
pub const NGHTTP2_STREAM_STATE_IDLE: nghttp2_stream_proto_state = 1;
/// open state.
pub const NGHTTP2_STREAM_STATE_OPEN: nghttp2_stream_proto_state = 2;
/// reserved (local) state.
pub const NGHTTP2_STREAM_STATE_RESERVED_LOCAL: nghttp2_stream_proto_state = 3;
/// reserved (remote) state.
pub const NGHTTP2_STREAM_STATE_RESERVED_REMOTE: nghttp2_stream_proto_state = 4;
/// half closed (local) state.
pub const NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: nghttp2_stream_proto_state = 5;
/// half closed (remote) state.
pub const NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: nghttp2_stream_proto_state = 6;
/// closed state.
pub const NGHTTP2_STREAM_STATE_CLOSED: nghttp2_stream_proto_state = 7;
/// @enum
///
/// State of stream as described in RFC 7540.
pub type nghttp2_stream_proto_state = u32;
extern "C" {
/// @function
///
/// Returns state of |stream|. The root stream retrieved by
/// `nghttp2_session_get_root_stream()` will have stream state
/// :enum:`NGHTTP2_STREAM_STATE_IDLE`.
pub fn nghttp2_stream_get_state(stream: *mut nghttp2_stream) -> nghttp2_stream_proto_state;
}
extern "C" {
/// @function
///
/// Returns root of dependency tree, which is imaginary stream with
/// stream ID 0. The returned pointer is valid until |session| is
/// freed by `nghttp2_session_del()`.
pub fn nghttp2_session_get_root_stream(session: *mut nghttp2_session) -> *mut nghttp2_stream;
}
extern "C" {
/// @function
///
/// Returns the parent stream of |stream| in dependency tree. Returns
/// NULL if there is no such stream.
pub fn nghttp2_stream_get_parent(stream: *mut nghttp2_stream) -> *mut nghttp2_stream;
}
extern "C" {
pub fn nghttp2_stream_get_stream_id(stream: *mut nghttp2_stream) -> i32;
}
extern "C" {
/// @function
///
/// Returns the next sibling stream of |stream| in dependency tree.
/// Returns NULL if there is no such stream.
pub fn nghttp2_stream_get_next_sibling(stream: *mut nghttp2_stream) -> *mut nghttp2_stream;
}
extern "C" {
/// @function
///
/// Returns the previous sibling stream of |stream| in dependency tree.
/// Returns NULL if there is no such stream.
pub fn nghttp2_stream_get_previous_sibling(stream: *mut nghttp2_stream) -> *mut nghttp2_stream;
}
extern "C" {
/// @function
///
/// Returns the first child stream of |stream| in dependency tree.
/// Returns NULL if there is no such stream.
pub fn nghttp2_stream_get_first_child(stream: *mut nghttp2_stream) -> *mut nghttp2_stream;
}
extern "C" {
/// @function
///
/// Returns dependency weight to the parent stream of |stream|.
pub fn nghttp2_stream_get_weight(stream: *mut nghttp2_stream) -> i32;
}
extern "C" {
/// @function
///
/// Returns the sum of the weight for |stream|'s children.
pub fn nghttp2_stream_get_sum_dependency_weight(stream: *mut nghttp2_stream) -> i32;
}