1pub const NGHTTP2_VERSION: &[u8; 7] = b"1.68.0\0";
4pub const NGHTTP2_VERSION_NUM: u32 = 82944;
5pub const NGHTTP2_PROTO_VERSION_ID: &[u8; 3] = b"h2\0";
6pub const NGHTTP2_PROTO_VERSION_ID_LEN: u32 = 2;
7pub const NGHTTP2_PROTO_ALPN: &[u8; 4] = b"\x02h2\0";
8pub const NGHTTP2_CLEARTEXT_PROTO_VERSION_ID: &[u8; 4] = b"h2c\0";
9pub const NGHTTP2_CLEARTEXT_PROTO_VERSION_ID_LEN: u32 = 3;
10pub const NGHTTP2_VERSION_AGE: u32 = 1;
11pub const NGHTTP2_DEFAULT_WEIGHT: u32 = 16;
12pub const NGHTTP2_MAX_WEIGHT: u32 = 256;
13pub const NGHTTP2_MIN_WEIGHT: u32 = 1;
14pub const NGHTTP2_INITIAL_WINDOW_SIZE: u32 = 65535;
15pub const NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE: u32 = 65535;
16pub const NGHTTP2_DEFAULT_HEADER_TABLE_SIZE: u32 = 4096;
17pub const NGHTTP2_CLIENT_MAGIC: &[u8; 25] =
18 b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n\0";
19pub const NGHTTP2_CLIENT_MAGIC_LEN: u32 = 24;
20pub const NGHTTP2_DEFAULT_MAX_SETTINGS: u32 = 32;
21pub const NGHTTP2_INITIAL_MAX_CONCURRENT_STREAMS: u32 = 2147483647;
22pub const NGHTTP2_EXTPRI_DEFAULT_URGENCY: u32 = 3;
23pub const NGHTTP2_EXTPRI_URGENCY_HIGH: u32 = 0;
24pub const NGHTTP2_EXTPRI_URGENCY_LOW: u32 = 7;
25pub const NGHTTP2_EXTPRI_URGENCY_LEVELS: u32 = 8;
26#[doc = " @typedef\n\n :type:`nghttp2_ssize` is a signed counterpart of size_t."]
27pub type nghttp2_ssize = isize;
28#[repr(C)]
29#[derive(Debug, Copy, Clone)]
30pub struct nghttp2_session {
31 _unused: [u8; 0],
32}
33#[doc = " @struct\n\n This struct is what `nghttp2_version()` returns. It holds\n information about the particular nghttp2 version."]
34#[repr(C)]
35#[derive(Debug, Copy, Clone)]
36pub struct nghttp2_info {
37 #[doc = " Age of this struct. This instance of nghttp2 sets it to\n :macro:`NGHTTP2_VERSION_AGE` but a future version may bump it and\n add more struct fields at the bottom"]
38 pub age: ::std::os::raw::c_int,
39 #[doc = " the :macro:`NGHTTP2_VERSION_NUM` number (since age ==1)"]
40 pub version_num: ::std::os::raw::c_int,
41 #[doc = " points to the :macro:`NGHTTP2_VERSION` string (since age ==1)"]
42 pub version_str: *const ::std::os::raw::c_char,
43 #[doc = " points to the :macro:`NGHTTP2_PROTO_VERSION_ID` string this\n instance implements (since age ==1)"]
44 pub proto_str: *const ::std::os::raw::c_char,
45}
46#[doc = " Invalid argument passed."]
47pub const NGHTTP2_ERR_INVALID_ARGUMENT: nghttp2_error = -501;
48#[doc = " Out of buffer space."]
49pub const NGHTTP2_ERR_BUFFER_ERROR: nghttp2_error = -502;
50#[doc = " The specified protocol version is not supported."]
51pub const NGHTTP2_ERR_UNSUPPORTED_VERSION: nghttp2_error = -503;
52#[doc = " Used as a return value from :type:`nghttp2_send_callback2`,\n :type:`nghttp2_recv_callback` and\n :type:`nghttp2_send_data_callback` to indicate that the operation\n would block."]
53pub const NGHTTP2_ERR_WOULDBLOCK: nghttp2_error = -504;
54#[doc = " General protocol error"]
55pub const NGHTTP2_ERR_PROTO: nghttp2_error = -505;
56#[doc = " The frame is invalid."]
57pub const NGHTTP2_ERR_INVALID_FRAME: nghttp2_error = -506;
58#[doc = " The peer performed a shutdown on the connection."]
59pub const NGHTTP2_ERR_EOF: nghttp2_error = -507;
60#[doc = " Used as a return value from\n :func:`nghttp2_data_source_read_callback2` to indicate that data\n transfer is postponed. See\n :func:`nghttp2_data_source_read_callback2` for details."]
61pub const NGHTTP2_ERR_DEFERRED: nghttp2_error = -508;
62#[doc = " Stream ID has reached the maximum value. Therefore no stream ID\n is available."]
63pub const NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE: nghttp2_error = -509;
64#[doc = " The stream is already closed; or the stream ID is invalid."]
65pub const NGHTTP2_ERR_STREAM_CLOSED: nghttp2_error = -510;
66#[doc = " RST_STREAM has been added to the outbound queue. The stream is\n in closing state."]
67pub const NGHTTP2_ERR_STREAM_CLOSING: nghttp2_error = -511;
68#[doc = " The transmission is not allowed for this stream (e.g., a frame\n with END_STREAM flag set has already sent)."]
69pub const NGHTTP2_ERR_STREAM_SHUT_WR: nghttp2_error = -512;
70#[doc = " The stream ID is invalid."]
71pub const NGHTTP2_ERR_INVALID_STREAM_ID: nghttp2_error = -513;
72#[doc = " The state of the stream is not valid (e.g., DATA cannot be sent\n to the stream if response HEADERS has not been sent)."]
73pub const NGHTTP2_ERR_INVALID_STREAM_STATE: nghttp2_error = -514;
74#[doc = " Another DATA frame has already been deferred."]
75pub const NGHTTP2_ERR_DEFERRED_DATA_EXIST: nghttp2_error = -515;
76#[doc = " Starting new stream is not allowed (e.g., GOAWAY has been sent\n and/or received)."]
77pub const NGHTTP2_ERR_START_STREAM_NOT_ALLOWED: nghttp2_error = -516;
78#[doc = " GOAWAY has already been sent."]
79pub const NGHTTP2_ERR_GOAWAY_ALREADY_SENT: nghttp2_error = -517;
80#[doc = " The received frame contains the invalid header block (e.g., There\n are duplicate header names; or the header names are not encoded\n in US-ASCII character set and not lower cased; or the header name\n is zero-length string; or the header value contains multiple\n in-sequence NUL bytes)."]
81pub const NGHTTP2_ERR_INVALID_HEADER_BLOCK: nghttp2_error = -518;
82#[doc = " Indicates that the context is not suitable to perform the\n requested operation."]
83pub const NGHTTP2_ERR_INVALID_STATE: nghttp2_error = -519;
84#[doc = " The user callback function failed due to the temporal error."]
85pub const NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE: nghttp2_error = -521;
86#[doc = " The length of the frame is invalid, either too large or too small."]
87pub const NGHTTP2_ERR_FRAME_SIZE_ERROR: nghttp2_error = -522;
88#[doc = " Header block inflate/deflate error."]
89pub const NGHTTP2_ERR_HEADER_COMP: nghttp2_error = -523;
90#[doc = " Flow control error"]
91pub const NGHTTP2_ERR_FLOW_CONTROL: nghttp2_error = -524;
92#[doc = " Insufficient buffer size given to function."]
93pub const NGHTTP2_ERR_INSUFF_BUFSIZE: nghttp2_error = -525;
94#[doc = " Callback was paused by the application"]
95pub const NGHTTP2_ERR_PAUSE: nghttp2_error = -526;
96#[doc = " There are too many in-flight SETTING frame and no more\n transmission of SETTINGS is allowed."]
97pub const NGHTTP2_ERR_TOO_MANY_INFLIGHT_SETTINGS: nghttp2_error = -527;
98#[doc = " The server push is disabled."]
99pub const NGHTTP2_ERR_PUSH_DISABLED: nghttp2_error = -528;
100#[doc = " DATA or HEADERS frame for a given stream has been already\n submitted and has not been fully processed yet. Application\n should wait for the transmission of the previously submitted\n frame before submitting another."]
101pub const NGHTTP2_ERR_DATA_EXIST: nghttp2_error = -529;
102#[doc = " The current session is closing due to a connection error or\n `nghttp2_session_terminate_session()` is called."]
103pub const NGHTTP2_ERR_SESSION_CLOSING: nghttp2_error = -530;
104#[doc = " Invalid HTTP header field was received and stream is going to be\n closed."]
105pub const NGHTTP2_ERR_HTTP_HEADER: nghttp2_error = -531;
106#[doc = " Violation in HTTP messaging rule."]
107pub const NGHTTP2_ERR_HTTP_MESSAGING: nghttp2_error = -532;
108#[doc = " Stream was refused."]
109pub const NGHTTP2_ERR_REFUSED_STREAM: nghttp2_error = -533;
110#[doc = " Unexpected internal error, but recovered."]
111pub const NGHTTP2_ERR_INTERNAL: nghttp2_error = -534;
112#[doc = " Indicates that a processing was canceled."]
113pub const NGHTTP2_ERR_CANCEL: nghttp2_error = -535;
114#[doc = " When a local endpoint expects to receive SETTINGS frame, it\n receives an other type of frame."]
115pub const NGHTTP2_ERR_SETTINGS_EXPECTED: nghttp2_error = -536;
116#[doc = " When a local endpoint receives too many settings entries\n in a single SETTINGS frame."]
117pub const NGHTTP2_ERR_TOO_MANY_SETTINGS: nghttp2_error = -537;
118#[doc = " The errors < :enum:`nghttp2_error.NGHTTP2_ERR_FATAL` mean that\n the library is under unexpected condition and processing was\n terminated (e.g., out of memory). If application receives this\n error code, it must stop using that :type:`nghttp2_session`\n object and only allowed operation for that object is deallocate\n it using `nghttp2_session_del()`."]
119pub const NGHTTP2_ERR_FATAL: nghttp2_error = -900;
120#[doc = " Out of memory. This is a fatal error."]
121pub const NGHTTP2_ERR_NOMEM: nghttp2_error = -901;
122#[doc = " The user callback function failed. This is a fatal error."]
123pub const NGHTTP2_ERR_CALLBACK_FAILURE: nghttp2_error = -902;
124#[doc = " Invalid client magic (see :macro:`NGHTTP2_CLIENT_MAGIC`) was\n received and further processing is not possible."]
125pub const NGHTTP2_ERR_BAD_CLIENT_MAGIC: nghttp2_error = -903;
126#[doc = " Possible flooding by peer was detected in this HTTP/2 session.\n Flooding is measured by how many PING and SETTINGS frames with\n ACK flag set are queued for transmission. These frames are\n response for the peer initiated frames, and peer can cause memory\n exhaustion on server side to send these frames forever and does\n not read network."]
127pub const NGHTTP2_ERR_FLOODED: nghttp2_error = -904;
128#[doc = " When a local endpoint receives too many CONTINUATION frames\n following a HEADER frame."]
129pub const NGHTTP2_ERR_TOO_MANY_CONTINUATIONS: nghttp2_error = -905;
130#[doc = " @enum\n\n Error codes used in this library. The code range is [-999, -500],\n inclusive. The following values are defined:"]
131pub type nghttp2_error = i32;
132#[doc = " @struct\n\n The object representing single contiguous buffer."]
133#[repr(C)]
134#[derive(Debug, Copy, Clone)]
135pub struct nghttp2_vec {
136 #[doc = " The pointer to the buffer."]
137 pub base: *mut u8,
138 #[doc = " The length of the buffer."]
139 pub len: usize,
140}
141#[repr(C)]
142#[derive(Debug, Copy, Clone)]
143pub struct nghttp2_rcbuf {
144 _unused: [u8; 0],
145}
146unsafe extern "C" {
147 #[doc = " @function\n\n Increments the reference count of |rcbuf| by 1."]
148 pub fn nghttp2_rcbuf_incref(rcbuf: *mut nghttp2_rcbuf);
149}
150unsafe extern "C" {
151 #[doc = " @function\n\n Decrements the reference count of |rcbuf| by 1. If the reference\n count becomes zero, the object pointed by |rcbuf| will be freed.\n In this case, application must not use |rcbuf| again."]
152 pub fn nghttp2_rcbuf_decref(rcbuf: *mut nghttp2_rcbuf);
153}
154unsafe extern "C" {
155 #[doc = " @function\n\n Returns the underlying buffer managed by |rcbuf|."]
156 pub fn nghttp2_rcbuf_get_buf(rcbuf: *mut nghttp2_rcbuf) -> nghttp2_vec;
157}
158unsafe extern "C" {
159 #[doc = " @function\n\n Returns nonzero if the underlying buffer is statically allocated,\n and 0 otherwise. This can be useful for language bindings that wish\n to avoid creating duplicate strings for these buffers."]
160 pub fn nghttp2_rcbuf_is_static(
161 rcbuf: *const nghttp2_rcbuf,
162 ) -> ::std::os::raw::c_int;
163}
164#[doc = " No flag set."]
165pub const NGHTTP2_NV_FLAG_NONE: nghttp2_nv_flag = 0;
166#[doc = " Indicates that this name/value pair must not be indexed (\"Literal\n Header Field never Indexed\" representation must be used in HPACK\n encoding). Other implementation calls this bit as \"sensitive\"."]
167pub const NGHTTP2_NV_FLAG_NO_INDEX: nghttp2_nv_flag = 1;
168#[doc = " This flag is set solely by application. If this flag is set, the\n library does not make a copy of header field name. This could\n improve performance."]
169pub const NGHTTP2_NV_FLAG_NO_COPY_NAME: nghttp2_nv_flag = 2;
170#[doc = " This flag is set solely by application. If this flag is set, the\n library does not make a copy of header field value. This could\n improve performance."]
171pub const NGHTTP2_NV_FLAG_NO_COPY_VALUE: nghttp2_nv_flag = 4;
172#[doc = " @enum\n\n The flags for header field name/value pair."]
173pub type nghttp2_nv_flag = u32;
174#[doc = " @struct\n\n The name/value pair, which mainly used to represent header fields."]
175#[repr(C)]
176#[derive(Debug, Copy, Clone)]
177pub struct nghttp2_nv {
178 #[doc = " The |name| byte string. If this struct is presented from library\n (e.g., :type:`nghttp2_on_frame_recv_callback`), |name| is\n guaranteed to be NULL-terminated. For some callbacks\n (:type:`nghttp2_before_frame_send_callback`,\n :type:`nghttp2_on_frame_send_callback`, and\n :type:`nghttp2_on_frame_not_send_callback`), it may not be\n NULL-terminated if header field is passed from application with\n the flag :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`).\n When application is constructing this struct, |name| is not\n required to be NULL-terminated."]
179 pub name: *mut u8,
180 #[doc = " The |value| byte string. If this struct is presented from\n library (e.g., :type:`nghttp2_on_frame_recv_callback`), |value|\n is guaranteed to be NULL-terminated. For some callbacks\n (:type:`nghttp2_before_frame_send_callback`,\n :type:`nghttp2_on_frame_send_callback`, and\n :type:`nghttp2_on_frame_not_send_callback`), it may not be\n NULL-terminated if header field is passed from application with\n the flag :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE`).\n When application is constructing this struct, |value| is not\n required to be NULL-terminated."]
181 pub value: *mut u8,
182 #[doc = " The length of the |name|, excluding terminating NULL."]
183 pub namelen: usize,
184 #[doc = " The length of the |value|, excluding terminating NULL."]
185 pub valuelen: usize,
186 #[doc = " Bitwise OR of one or more of :type:`nghttp2_nv_flag`."]
187 pub flags: u8,
188}
189#[doc = " The DATA frame."]
190pub const NGHTTP2_DATA: nghttp2_frame_type = 0;
191#[doc = " The HEADERS frame."]
192pub const NGHTTP2_HEADERS: nghttp2_frame_type = 1;
193#[doc = " The PRIORITY frame."]
194pub const NGHTTP2_PRIORITY: nghttp2_frame_type = 2;
195#[doc = " The RST_STREAM frame."]
196pub const NGHTTP2_RST_STREAM: nghttp2_frame_type = 3;
197#[doc = " The SETTINGS frame."]
198pub const NGHTTP2_SETTINGS: nghttp2_frame_type = 4;
199#[doc = " The PUSH_PROMISE frame."]
200pub const NGHTTP2_PUSH_PROMISE: nghttp2_frame_type = 5;
201#[doc = " The PING frame."]
202pub const NGHTTP2_PING: nghttp2_frame_type = 6;
203#[doc = " The GOAWAY frame."]
204pub const NGHTTP2_GOAWAY: nghttp2_frame_type = 7;
205#[doc = " The WINDOW_UPDATE frame."]
206pub const NGHTTP2_WINDOW_UPDATE: nghttp2_frame_type = 8;
207#[doc = " The CONTINUATION frame. This frame type won't be passed to any\n callbacks because the library processes this frame type and its\n preceding HEADERS/PUSH_PROMISE as a single frame."]
208pub const NGHTTP2_CONTINUATION: nghttp2_frame_type = 9;
209#[doc = " The ALTSVC frame, which is defined in `RFC 7383\n <https://tools.ietf.org/html/rfc7838#section-4>`_."]
210pub const NGHTTP2_ALTSVC: nghttp2_frame_type = 10;
211#[doc = " The ORIGIN frame, which is defined by `RFC 8336\n <https://tools.ietf.org/html/rfc8336>`_."]
212pub const NGHTTP2_ORIGIN: nghttp2_frame_type = 12;
213#[doc = " The PRIORITY_UPDATE frame, which is defined by :rfc:`9218`."]
214pub const NGHTTP2_PRIORITY_UPDATE: nghttp2_frame_type = 16;
215#[doc = " @enum\n\n The frame types in HTTP/2 specification."]
216pub type nghttp2_frame_type = u32;
217#[doc = " No flag set."]
218pub const NGHTTP2_FLAG_NONE: nghttp2_flag = 0;
219#[doc = " The END_STREAM flag."]
220pub const NGHTTP2_FLAG_END_STREAM: nghttp2_flag = 1;
221#[doc = " The END_HEADERS flag."]
222pub const NGHTTP2_FLAG_END_HEADERS: nghttp2_flag = 4;
223#[doc = " The ACK flag."]
224pub const NGHTTP2_FLAG_ACK: nghttp2_flag = 1;
225#[doc = " The PADDED flag."]
226pub const NGHTTP2_FLAG_PADDED: nghttp2_flag = 8;
227#[doc = " The PRIORITY flag."]
228pub const NGHTTP2_FLAG_PRIORITY: nghttp2_flag = 32;
229#[doc = " @enum\n\n The flags for HTTP/2 frames. This enum defines all flags for all\n frames."]
230pub type nghttp2_flag = u32;
231#[doc = " SETTINGS_HEADER_TABLE_SIZE"]
232pub const NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: nghttp2_settings_id = 1;
233#[doc = " SETTINGS_ENABLE_PUSH"]
234pub const NGHTTP2_SETTINGS_ENABLE_PUSH: nghttp2_settings_id = 2;
235#[doc = " SETTINGS_MAX_CONCURRENT_STREAMS"]
236pub const NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: nghttp2_settings_id = 3;
237#[doc = " SETTINGS_INITIAL_WINDOW_SIZE"]
238pub const NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: nghttp2_settings_id = 4;
239#[doc = " SETTINGS_MAX_FRAME_SIZE"]
240pub const NGHTTP2_SETTINGS_MAX_FRAME_SIZE: nghttp2_settings_id = 5;
241#[doc = " SETTINGS_MAX_HEADER_LIST_SIZE"]
242pub const NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: nghttp2_settings_id = 6;
243#[doc = " SETTINGS_ENABLE_CONNECT_PROTOCOL\n (`RFC 8441 <https://tools.ietf.org/html/rfc8441>`_)"]
244pub const NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL: nghttp2_settings_id = 8;
245#[doc = " SETTINGS_NO_RFC7540_PRIORITIES (:rfc:`9218`)"]
246pub const NGHTTP2_SETTINGS_NO_RFC7540_PRIORITIES: nghttp2_settings_id = 9;
247#[doc = " @enum\n The SETTINGS ID."]
248pub type nghttp2_settings_id = u32;
249#[doc = " No errors."]
250pub const NGHTTP2_NO_ERROR: nghttp2_error_code = 0;
251#[doc = " PROTOCOL_ERROR"]
252pub const NGHTTP2_PROTOCOL_ERROR: nghttp2_error_code = 1;
253#[doc = " INTERNAL_ERROR"]
254pub const NGHTTP2_INTERNAL_ERROR: nghttp2_error_code = 2;
255#[doc = " FLOW_CONTROL_ERROR"]
256pub const NGHTTP2_FLOW_CONTROL_ERROR: nghttp2_error_code = 3;
257#[doc = " SETTINGS_TIMEOUT"]
258pub const NGHTTP2_SETTINGS_TIMEOUT: nghttp2_error_code = 4;
259#[doc = " STREAM_CLOSED"]
260pub const NGHTTP2_STREAM_CLOSED: nghttp2_error_code = 5;
261#[doc = " FRAME_SIZE_ERROR"]
262pub const NGHTTP2_FRAME_SIZE_ERROR: nghttp2_error_code = 6;
263#[doc = " REFUSED_STREAM"]
264pub const NGHTTP2_REFUSED_STREAM: nghttp2_error_code = 7;
265#[doc = " CANCEL"]
266pub const NGHTTP2_CANCEL: nghttp2_error_code = 8;
267#[doc = " COMPRESSION_ERROR"]
268pub const NGHTTP2_COMPRESSION_ERROR: nghttp2_error_code = 9;
269#[doc = " CONNECT_ERROR"]
270pub const NGHTTP2_CONNECT_ERROR: nghttp2_error_code = 10;
271#[doc = " ENHANCE_YOUR_CALM"]
272pub const NGHTTP2_ENHANCE_YOUR_CALM: nghttp2_error_code = 11;
273#[doc = " INADEQUATE_SECURITY"]
274pub const NGHTTP2_INADEQUATE_SECURITY: nghttp2_error_code = 12;
275#[doc = " HTTP_1_1_REQUIRED"]
276pub const NGHTTP2_HTTP_1_1_REQUIRED: nghttp2_error_code = 13;
277#[doc = " @enum\n The status codes for the RST_STREAM and GOAWAY frames."]
278pub type nghttp2_error_code = u32;
279#[doc = " @struct\n The frame header."]
280#[repr(C)]
281#[derive(Debug, Copy, Clone)]
282pub struct nghttp2_frame_hd {
283 #[doc = " The length field of this frame, excluding frame header."]
284 pub length: usize,
285 #[doc = " The stream identifier (aka, stream ID)"]
286 pub stream_id: i32,
287 #[doc = " The type of this frame. See `nghttp2_frame_type`."]
288 pub type_: u8,
289 #[doc = " The flags."]
290 pub flags: u8,
291 #[doc = " Reserved bit in frame header. Currently, this is always set to 0\n and application should not expect something useful in here."]
292 pub reserved: u8,
293}
294#[doc = " @union\n\n This union represents the some kind of data source passed to\n :type:`nghttp2_data_source_read_callback2`."]
295#[repr(C)]
296#[derive(Copy, Clone)]
297pub union nghttp2_data_source {
298 #[doc = " The integer field, suitable for a file descriptor."]
299 pub fd: ::std::os::raw::c_int,
300 #[doc = " The pointer to an arbitrary object."]
301 pub ptr: *mut ::std::os::raw::c_void,
302}
303#[doc = " No flag set."]
304pub const NGHTTP2_DATA_FLAG_NONE: nghttp2_data_flag = 0;
305#[doc = " Indicates EOF was sensed."]
306pub const NGHTTP2_DATA_FLAG_EOF: nghttp2_data_flag = 1;
307#[doc = " Indicates that END_STREAM flag must not be set even if\n NGHTTP2_DATA_FLAG_EOF is set. Usually this flag is used to send\n trailer fields with `nghttp2_submit_request2()` or\n `nghttp2_submit_response2()`."]
308pub const NGHTTP2_DATA_FLAG_NO_END_STREAM: nghttp2_data_flag = 2;
309#[doc = " Indicates that application will send complete DATA frame in\n :type:`nghttp2_send_data_callback`."]
310pub const NGHTTP2_DATA_FLAG_NO_COPY: nghttp2_data_flag = 4;
311#[doc = " @enum\n\n The flags used to set in |data_flags| output parameter in\n :type:`nghttp2_data_source_read_callback2`."]
312pub type nghttp2_data_flag = u32;
313#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_data_source_read_callback2`\n instead.\n\n Callback function invoked when the library wants to read data from\n the |source|. The read data is sent in the stream |stream_id|.\n The implementation of this function must read at most |length|\n bytes of data from |source| (or possibly other places) and store\n them in |buf| and return number of data stored in |buf|. If EOF is\n reached, set :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` flag\n in |*data_flags|.\n\n Sometime it is desirable to avoid copying data into |buf| and let\n application to send data directly. To achieve this, set\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY` to\n |*data_flags| (and possibly other flags, just like when we do\n copy), and return the number of bytes to send without copying data\n into |buf|. The library, seeing\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY`, will invoke\n :type:`nghttp2_send_data_callback`. The application must send\n complete DATA frame in that callback.\n\n If this callback is set by `nghttp2_submit_request()`,\n `nghttp2_submit_response()` or `nghttp2_submit_headers()` and\n `nghttp2_submit_data()` with flag parameter\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM` set, and\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` flag is set to\n |*data_flags|, DATA frame will have END_STREAM flag set. Usually,\n this is expected behaviour and all are fine. One exception is send\n trailer fields. You cannot send trailer fields after sending frame\n with END_STREAM set. To avoid this problem, one can set\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_END_STREAM` along\n with :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` to signal the\n library not to set END_STREAM in DATA frame. Then application can\n use `nghttp2_submit_trailer()` to send trailer fields.\n `nghttp2_submit_trailer()` can be called inside this callback.\n\n If the application wants to postpone DATA frames (e.g.,\n asynchronous I/O, or reading data blocks for long time), it is\n achieved by returning :enum:`nghttp2_error.NGHTTP2_ERR_DEFERRED`\n without reading any data in this invocation. The library removes\n DATA frame from the outgoing queue temporarily. To move back\n deferred DATA frame to outgoing queue, call\n `nghttp2_session_resume_data()`.\n\n By default, |length| is limited to 16KiB at maximum. If peer\n allows larger frames, application can enlarge transmission buffer\n size. See :type:`nghttp2_data_source_read_length_callback` for\n more details.\n\n If the application just wants to return from\n `nghttp2_session_send()` or `nghttp2_session_mem_send()` without\n sending anything, return :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE`.\n\n In case of error, there are 2 choices. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will\n close the stream by issuing RST_STREAM with\n :enum:`nghttp2_error_code.NGHTTP2_INTERNAL_ERROR`. If a different\n error code is desirable, use `nghttp2_submit_rst_stream()` with a\n desired error code and then return\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.\n Returning :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will\n signal the entire session failure."]
314pub type nghttp2_data_source_read_callback = ::std::option::Option<
315 unsafe extern "C" fn(
316 session: *mut nghttp2_session,
317 stream_id: i32,
318 buf: *mut u8,
319 length: usize,
320 data_flags: *mut u32,
321 source: *mut nghttp2_data_source,
322 user_data: *mut ::std::os::raw::c_void,
323 ) -> isize,
324>;
325#[doc = " @functypedef\n\n Callback function invoked when the library wants to read data from\n the |source|. The read data is sent in the stream |stream_id|.\n The implementation of this function must read at most |length|\n bytes of data from |source| (or possibly other places) and store\n them in |buf| and return number of data stored in |buf|. If EOF is\n reached, set :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` flag\n in |*data_flags|.\n\n Sometime it is desirable to avoid copying data into |buf| and let\n application to send data directly. To achieve this, set\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY` to\n |*data_flags| (and possibly other flags, just like when we do\n copy), and return the number of bytes to send without copying data\n into |buf|. The library, seeing\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY`, will invoke\n :type:`nghttp2_send_data_callback`. The application must send\n complete DATA frame in that callback.\n\n If this callback is set by `nghttp2_submit_request2()`,\n `nghttp2_submit_response2()` or `nghttp2_submit_headers()` and\n `nghttp2_submit_data2()` with flag parameter\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM` set, and\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` flag is set to\n |*data_flags|, DATA frame will have END_STREAM flag set. Usually,\n this is expected behaviour and all are fine. One exception is send\n trailer fields. You cannot send trailer fields after sending frame\n with END_STREAM set. To avoid this problem, one can set\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_END_STREAM` along\n with :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF` to signal the\n library not to set END_STREAM in DATA frame. Then application can\n use `nghttp2_submit_trailer()` to send trailer fields.\n `nghttp2_submit_trailer()` can be called inside this callback.\n\n If the application wants to postpone DATA frames (e.g.,\n asynchronous I/O, or reading data blocks for long time), it is\n achieved by returning :enum:`nghttp2_error.NGHTTP2_ERR_DEFERRED`\n without reading any data in this invocation. The library removes\n DATA frame from the outgoing queue temporarily. To move back\n deferred DATA frame to outgoing queue, call\n `nghttp2_session_resume_data()`.\n\n By default, |length| is limited to 16KiB at maximum. If peer\n allows larger frames, application can enlarge transmission buffer\n size. See :type:`nghttp2_data_source_read_length_callback` for\n more details.\n\n If the application just wants to return from\n `nghttp2_session_send()` or `nghttp2_session_mem_send2()` without\n sending anything, return :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE`.\n\n In case of error, there are 2 choices. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will\n close the stream by issuing RST_STREAM with\n :enum:`nghttp2_error_code.NGHTTP2_INTERNAL_ERROR`. If a different\n error code is desirable, use `nghttp2_submit_rst_stream()` with a\n desired error code and then return\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.\n Returning :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will\n signal the entire session failure."]
326pub type nghttp2_data_source_read_callback2 = ::std::option::Option<
327 unsafe extern "C" fn(
328 session: *mut nghttp2_session,
329 stream_id: i32,
330 buf: *mut u8,
331 length: usize,
332 data_flags: *mut u32,
333 source: *mut nghttp2_data_source,
334 user_data: *mut ::std::os::raw::c_void,
335 ) -> nghttp2_ssize,
336>;
337#[doc = " @struct\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_data_provider2` instead.\n\n This struct represents the data source and the way to read a chunk\n of data from it."]
338#[repr(C)]
339#[derive(Copy, Clone)]
340pub struct nghttp2_data_provider {
341 #[doc = " The data source."]
342 pub source: nghttp2_data_source,
343 #[doc = " The callback function to read a chunk of data from the |source|."]
344 pub read_callback: nghttp2_data_source_read_callback,
345}
346#[doc = " @struct\n\n This struct represents the data source and the way to read a chunk\n of data from it."]
347#[repr(C)]
348#[derive(Copy, Clone)]
349pub struct nghttp2_data_provider2 {
350 #[doc = " The data source."]
351 pub source: nghttp2_data_source,
352 #[doc = " The callback function to read a chunk of data from the |source|."]
353 pub read_callback: nghttp2_data_source_read_callback2,
354}
355#[doc = " @struct\n\n The DATA frame. The received data is delivered via\n :type:`nghttp2_on_data_chunk_recv_callback`."]
356#[repr(C)]
357#[derive(Debug, Copy, Clone)]
358pub struct nghttp2_data {
359 pub hd: nghttp2_frame_hd,
360 #[doc = " The length of the padding in this frame. This includes PAD_HIGH\n and PAD_LOW."]
361 pub padlen: usize,
362}
363#[doc = " The HEADERS frame is opening new stream, which is analogous to\n SYN_STREAM in SPDY."]
364pub const NGHTTP2_HCAT_REQUEST: nghttp2_headers_category = 0;
365#[doc = " The HEADERS frame is the first response headers, which is\n analogous to SYN_REPLY in SPDY."]
366pub const NGHTTP2_HCAT_RESPONSE: nghttp2_headers_category = 1;
367#[doc = " The HEADERS frame is the first headers sent against reserved\n stream."]
368pub const NGHTTP2_HCAT_PUSH_RESPONSE: nghttp2_headers_category = 2;
369#[doc = " The HEADERS frame which does not apply for the above categories,\n which is analogous to HEADERS in SPDY. If non-final response\n (e.g., status 1xx) is used, final response HEADERS frame will be\n categorized here."]
370pub const NGHTTP2_HCAT_HEADERS: nghttp2_headers_category = 3;
371#[doc = " @enum\n\n The category of HEADERS, which indicates the role of the frame. In\n HTTP/2 spec, request, response, push response and other arbitrary\n headers (e.g., trailer fields) are all called just HEADERS. To\n give the application the role of incoming HEADERS frame, we define\n several categories."]
372pub type nghttp2_headers_category = u32;
373#[doc = " @struct\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n The structure to specify stream dependency."]
374#[repr(C)]
375#[derive(Debug, Copy, Clone)]
376pub struct nghttp2_priority_spec {
377 #[doc = " The stream ID of the stream to depend on. Specifying 0 makes\n stream not depend any other stream."]
378 pub stream_id: i32,
379 #[doc = " The weight of this dependency."]
380 pub weight: i32,
381 #[doc = " nonzero means exclusive dependency"]
382 pub exclusive: u8,
383}
384#[doc = " @struct\n\n The HEADERS frame. It has the following members:"]
385#[repr(C)]
386#[derive(Debug, Copy, Clone)]
387pub struct nghttp2_headers {
388 #[doc = " The frame header."]
389 pub hd: nghttp2_frame_hd,
390 #[doc = " The length of the padding in this frame. This includes PAD_HIGH\n and PAD_LOW."]
391 pub padlen: usize,
392 #[doc = " .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n The priority specification"]
393 pub pri_spec: nghttp2_priority_spec,
394 #[doc = " The name/value pairs."]
395 pub nva: *mut nghttp2_nv,
396 #[doc = " The number of name/value pairs in |nva|."]
397 pub nvlen: usize,
398 #[doc = " The category of this HEADERS frame."]
399 pub cat: nghttp2_headers_category,
400}
401#[doc = " @struct\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n The PRIORITY frame. It has the following members:"]
402#[repr(C)]
403#[derive(Debug, Copy, Clone)]
404pub struct nghttp2_priority {
405 #[doc = " The frame header."]
406 pub hd: nghttp2_frame_hd,
407 #[doc = " The priority specification."]
408 pub pri_spec: nghttp2_priority_spec,
409}
410#[doc = " @struct\n\n The RST_STREAM frame. It has the following members:"]
411#[repr(C)]
412#[derive(Debug, Copy, Clone)]
413pub struct nghttp2_rst_stream {
414 #[doc = " The frame header."]
415 pub hd: nghttp2_frame_hd,
416 #[doc = " The error code. See :type:`nghttp2_error_code`."]
417 pub error_code: u32,
418}
419#[doc = " @struct\n\n The SETTINGS ID/Value pair. It has the following members:"]
420#[repr(C)]
421#[derive(Debug, Copy, Clone)]
422pub struct nghttp2_settings_entry {
423 #[doc = " The SETTINGS ID. See :type:`nghttp2_settings_id`."]
424 pub settings_id: i32,
425 #[doc = " The value of this entry."]
426 pub value: u32,
427}
428#[doc = " @struct\n\n The SETTINGS frame. It has the following members:"]
429#[repr(C)]
430#[derive(Debug, Copy, Clone)]
431pub struct nghttp2_settings {
432 #[doc = " The frame header."]
433 pub hd: nghttp2_frame_hd,
434 #[doc = " The number of SETTINGS ID/Value pairs in |iv|."]
435 pub niv: usize,
436 #[doc = " The pointer to the array of SETTINGS ID/Value pair."]
437 pub iv: *mut nghttp2_settings_entry,
438}
439#[doc = " @struct\n\n The PUSH_PROMISE frame. It has the following members:"]
440#[repr(C)]
441#[derive(Debug, Copy, Clone)]
442pub struct nghttp2_push_promise {
443 #[doc = " The frame header."]
444 pub hd: nghttp2_frame_hd,
445 #[doc = " The length of the padding in this frame. This includes PAD_HIGH\n and PAD_LOW."]
446 pub padlen: usize,
447 #[doc = " The name/value pairs."]
448 pub nva: *mut nghttp2_nv,
449 #[doc = " The number of name/value pairs in |nva|."]
450 pub nvlen: usize,
451 #[doc = " The promised stream ID"]
452 pub promised_stream_id: i32,
453 #[doc = " Reserved bit. Currently this is always set to 0 and application\n should not expect something useful in here."]
454 pub reserved: u8,
455}
456#[doc = " @struct\n\n The PING frame. It has the following members:"]
457#[repr(C)]
458#[derive(Debug, Copy, Clone)]
459pub struct nghttp2_ping {
460 #[doc = " The frame header."]
461 pub hd: nghttp2_frame_hd,
462 #[doc = " The opaque data"]
463 pub opaque_data: [u8; 8usize],
464}
465#[doc = " @struct\n\n The GOAWAY frame. It has the following members:"]
466#[repr(C)]
467#[derive(Debug, Copy, Clone)]
468pub struct nghttp2_goaway {
469 #[doc = " The frame header."]
470 pub hd: nghttp2_frame_hd,
471 #[doc = " The last stream stream ID."]
472 pub last_stream_id: i32,
473 #[doc = " The error code. See :type:`nghttp2_error_code`."]
474 pub error_code: u32,
475 #[doc = " The additional debug data"]
476 pub opaque_data: *mut u8,
477 #[doc = " The length of |opaque_data| member."]
478 pub opaque_data_len: usize,
479 #[doc = " Reserved bit. Currently this is always set to 0 and application\n should not expect something useful in here."]
480 pub reserved: u8,
481}
482#[doc = " @struct\n\n The WINDOW_UPDATE frame. It has the following members:"]
483#[repr(C)]
484#[derive(Debug, Copy, Clone)]
485pub struct nghttp2_window_update {
486 #[doc = " The frame header."]
487 pub hd: nghttp2_frame_hd,
488 #[doc = " The window size increment."]
489 pub window_size_increment: i32,
490 #[doc = " Reserved bit. Currently this is always set to 0 and application\n should not expect something useful in here."]
491 pub reserved: u8,
492}
493#[doc = " @struct\n\n The extension frame. It has following members:"]
494#[repr(C)]
495#[derive(Debug, Copy, Clone)]
496pub struct nghttp2_extension {
497 #[doc = " The frame header."]
498 pub hd: nghttp2_frame_hd,
499 #[doc = " The pointer to extension payload. The exact pointer type is\n determined by hd.type.\n\n Currently, no extension is supported. This is a place holder for\n the future extensions."]
500 pub payload: *mut ::std::os::raw::c_void,
501}
502#[doc = " @union\n\n This union includes all frames to pass them to various function\n calls as nghttp2_frame type. The CONTINUATION frame is omitted\n from here because the library deals with it internally."]
503#[repr(C)]
504#[derive(Copy, Clone)]
505pub union nghttp2_frame {
506 #[doc = " The frame header, which is convenient to inspect frame header."]
507 pub hd: nghttp2_frame_hd,
508 #[doc = " The DATA frame."]
509 pub data: nghttp2_data,
510 #[doc = " The HEADERS frame."]
511 pub headers: nghttp2_headers,
512 #[doc = " The PRIORITY frame."]
513 pub priority: nghttp2_priority,
514 #[doc = " The RST_STREAM frame."]
515 pub rst_stream: nghttp2_rst_stream,
516 #[doc = " The SETTINGS frame."]
517 pub settings: nghttp2_settings,
518 #[doc = " The PUSH_PROMISE frame."]
519 pub push_promise: nghttp2_push_promise,
520 #[doc = " The PING frame."]
521 pub ping: nghttp2_ping,
522 #[doc = " The GOAWAY frame."]
523 pub goaway: nghttp2_goaway,
524 #[doc = " The WINDOW_UPDATE frame."]
525 pub window_update: nghttp2_window_update,
526 #[doc = " The extension frame."]
527 pub ext: nghttp2_extension,
528}
529#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_send_callback2` instead.\n\n Callback function invoked when |session| wants to send data to the\n remote peer. The implementation of this function must send at most\n |length| bytes of data stored in |data|. The |flags| is currently\n not used and always 0. It must return the number of bytes sent if\n it succeeds. If it cannot send any single byte without blocking,\n it must return :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. For\n other errors, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. The\n |user_data| pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n This callback is required if the application uses\n `nghttp2_session_send()` to send data to the remote endpoint. If\n the application uses solely `nghttp2_session_mem_send()` instead,\n this callback function is unnecessary.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_send_callback()`.\n\n .. note::\n\n The |length| may be very small. If that is the case, and\n application disables Nagle algorithm (``TCP_NODELAY``), then just\n writing |data| to the network stack leads to very small packet,\n and it is very inefficient. An application should be responsible\n to buffer up small chunks of data as necessary to avoid this\n situation."]
530pub type nghttp2_send_callback = ::std::option::Option<
531 unsafe extern "C" fn(
532 session: *mut nghttp2_session,
533 data: *const u8,
534 length: usize,
535 flags: ::std::os::raw::c_int,
536 user_data: *mut ::std::os::raw::c_void,
537 ) -> isize,
538>;
539#[doc = " @functypedef\n\n Callback function invoked when |session| wants to send data to the\n remote peer. The implementation of this function must send at most\n |length| bytes of data stored in |data|. The |flags| is currently\n not used and always 0. It must return the number of bytes sent if\n it succeeds. If it cannot send any single byte without blocking,\n it must return :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. For\n other errors, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. The\n |user_data| pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n This callback is required if the application uses\n `nghttp2_session_send()` to send data to the remote endpoint. If\n the application uses solely `nghttp2_session_mem_send2()` instead,\n this callback function is unnecessary.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_send_callback2()`.\n\n .. note::\n\n The |length| may be very small. If that is the case, and\n application disables Nagle algorithm (``TCP_NODELAY``), then just\n writing |data| to the network stack leads to very small packet,\n and it is very inefficient. An application should be responsible\n to buffer up small chunks of data as necessary to avoid this\n situation."]
540pub type nghttp2_send_callback2 = ::std::option::Option<
541 unsafe extern "C" fn(
542 session: *mut nghttp2_session,
543 data: *const u8,
544 length: usize,
545 flags: ::std::os::raw::c_int,
546 user_data: *mut ::std::os::raw::c_void,
547 ) -> nghttp2_ssize,
548>;
549#[doc = " @functypedef\n\n Callback function invoked when\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY` is used in\n :type:`nghttp2_data_source_read_callback` to send complete DATA\n frame.\n\n The |frame| is a DATA frame to send. The |framehd| is the\n serialized frame header (9 bytes). The |length| is the length of\n application data to send (this does not include padding). The\n |source| is the same pointer passed to\n :type:`nghttp2_data_source_read_callback`.\n\n The application first must send frame header |framehd| of length 9\n bytes. If ``frame->data.padlen > 0``, send 1 byte of value\n ``frame->data.padlen - 1``. Then send exactly |length| bytes of\n application data. Finally, if ``frame->data.padlen > 1``, send\n ``frame->data.padlen - 1`` bytes of zero as padding.\n\n The application has to send complete DATA frame in this callback.\n If all data were written successfully, return 0.\n\n If it cannot send any data at all, just return\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`; the library will call\n this callback with the same parameters later (It is recommended to\n send complete DATA frame at once in this function to deal with\n error; if partial frame data has already sent, it is impossible to\n send another data in that state, and all we can do is tear down\n connection). When data is fully processed, but application wants\n to make `nghttp2_session_mem_send2()` or `nghttp2_session_send()`\n return immediately without processing next frames, return\n :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE`. If application decided to\n reset this stream, return\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`, then\n the library will send RST_STREAM with INTERNAL_ERROR as error code.\n The application can also return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`, which will\n result in connection closure. Returning any other value is treated\n as :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` is returned."]
550pub type nghttp2_send_data_callback = ::std::option::Option<
551 unsafe extern "C" fn(
552 session: *mut nghttp2_session,
553 frame: *mut nghttp2_frame,
554 framehd: *const u8,
555 length: usize,
556 source: *mut nghttp2_data_source,
557 user_data: *mut ::std::os::raw::c_void,
558 ) -> ::std::os::raw::c_int,
559>;
560#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_recv_callback2` instead.\n\n Callback function invoked when |session| wants to receive data from\n the remote peer. The implementation of this function must read at\n most |length| bytes of data and store it in |buf|. The |flags| is\n currently not used and always 0. It must return the number of\n bytes written in |buf| if it succeeds. If it cannot read any\n single byte without blocking, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. If it gets EOF\n before it reads any single byte, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_EOF`. For other errors, it must\n return :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n Returning 0 is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. The |user_data|\n pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n This callback is required if the application uses\n `nghttp2_session_recv()` to receive data from the remote endpoint.\n If the application uses solely `nghttp2_session_mem_recv()`\n instead, this callback function is unnecessary.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_recv_callback()`."]
561pub type nghttp2_recv_callback = ::std::option::Option<
562 unsafe extern "C" fn(
563 session: *mut nghttp2_session,
564 buf: *mut u8,
565 length: usize,
566 flags: ::std::os::raw::c_int,
567 user_data: *mut ::std::os::raw::c_void,
568 ) -> isize,
569>;
570#[doc = " @functypedef\n\n Callback function invoked when |session| wants to receive data from\n the remote peer. The implementation of this function must read at\n most |length| bytes of data and store it in |buf|. The |flags| is\n currently not used and always 0. It must return the number of\n bytes written in |buf| if it succeeds. If it cannot read any\n single byte without blocking, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. If it gets EOF\n before it reads any single byte, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_EOF`. For other errors, it must\n return :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n Returning 0 is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. The |user_data|\n pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n This callback is required if the application uses\n `nghttp2_session_recv()` to receive data from the remote endpoint.\n If the application uses solely `nghttp2_session_mem_recv2()`\n instead, this callback function is unnecessary.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_recv_callback2()`."]
571pub type nghttp2_recv_callback2 = ::std::option::Option<
572 unsafe extern "C" fn(
573 session: *mut nghttp2_session,
574 buf: *mut u8,
575 length: usize,
576 flags: ::std::os::raw::c_int,
577 user_data: *mut ::std::os::raw::c_void,
578 ) -> nghttp2_ssize,
579>;
580#[doc = " @functypedef\n\n Callback function invoked by `nghttp2_session_recv()` and\n `nghttp2_session_mem_recv2()` when a frame is received. The\n |user_data| pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n If frame is HEADERS or PUSH_PROMISE, the ``nva`` and ``nvlen``\n member of their data structure are always ``NULL`` and 0\n respectively. The header name/value pairs are emitted via\n :type:`nghttp2_on_header_callback`.\n\n Only HEADERS and DATA frame can signal the end of incoming data.\n If ``frame->hd.flags & NGHTTP2_FLAG_END_STREAM`` is nonzero, the\n |frame| is the last frame from the remote peer in this stream.\n\n This callback won't be called for CONTINUATION frames.\n HEADERS/PUSH_PROMISE + CONTINUATIONs are treated as single frame.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero value is returned, it is treated as fatal error and\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_frame_recv_callback()`."]
581pub type nghttp2_on_frame_recv_callback = ::std::option::Option<
582 unsafe extern "C" fn(
583 session: *mut nghttp2_session,
584 frame: *const nghttp2_frame,
585 user_data: *mut ::std::os::raw::c_void,
586 ) -> ::std::os::raw::c_int,
587>;
588#[doc = " @functypedef\n\n Callback function invoked by `nghttp2_session_recv()` and\n `nghttp2_session_mem_recv2()` when an invalid non-DATA frame is\n received. The error is indicated by the |lib_error_code|, which is\n one of the values defined in :type:`nghttp2_error`. When this\n callback function is invoked, the library automatically submits\n either RST_STREAM or GOAWAY frame. The |user_data| pointer is the\n third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n If frame is HEADERS or PUSH_PROMISE, the ``nva`` and ``nvlen``\n member of their data structure are always ``NULL`` and 0\n respectively.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero is returned, it is treated as fatal error and\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_invalid_frame_recv_callback()`."]
589pub type nghttp2_on_invalid_frame_recv_callback = ::std::option::Option<
590 unsafe extern "C" fn(
591 session: *mut nghttp2_session,
592 frame: *const nghttp2_frame,
593 lib_error_code: ::std::os::raw::c_int,
594 user_data: *mut ::std::os::raw::c_void,
595 ) -> ::std::os::raw::c_int,
596>;
597#[doc = " @functypedef\n\n Callback function invoked when a chunk of data in DATA frame is\n received. The |stream_id| is the stream ID this DATA frame belongs\n to. The |flags| is the flags of DATA frame which this data chunk\n is contained. ``(flags & NGHTTP2_FLAG_END_STREAM) != 0`` does not\n necessarily mean this chunk of data is the last one in the stream.\n You should use :type:`nghttp2_on_frame_recv_callback` to know all\n data frames are received. The |user_data| pointer is the third\n argument passed in to the call to `nghttp2_session_client_new()` or\n `nghttp2_session_server_new()`.\n\n If the application uses `nghttp2_session_mem_recv2()`, it can\n return :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` to make\n `nghttp2_session_mem_recv2()` return without processing further\n input bytes. The memory by pointed by the |data| is retained until\n `nghttp2_session_mem_recv2()` or `nghttp2_session_recv()` is\n called. The application must retain the input bytes which was used\n to produce the |data| parameter, because it may refer to the memory\n region included in the input bytes.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero is returned, it is treated as fatal error, and\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_data_chunk_recv_callback()`."]
598pub type nghttp2_on_data_chunk_recv_callback = ::std::option::Option<
599 unsafe extern "C" fn(
600 session: *mut nghttp2_session,
601 flags: u8,
602 stream_id: i32,
603 data: *const u8,
604 len: usize,
605 user_data: *mut ::std::os::raw::c_void,
606 ) -> ::std::os::raw::c_int,
607>;
608#[doc = " @functypedef\n\n Callback function invoked just before the non-DATA frame |frame| is\n sent. The |user_data| pointer is the third argument passed in to\n the call to `nghttp2_session_client_new()` or\n `nghttp2_session_server_new()`.\n\n The implementation of this function must return 0 if it succeeds.\n It can also return :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL` to\n cancel the transmission of the given frame.\n\n If there is a fatal error while executing this callback, the\n implementation should return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`, which makes\n `nghttp2_session_send()` and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n If the other value is returned, it is treated as if\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` is returned.\n But the implementation should not rely on this since the library\n may define new return value to extend its capability.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_before_frame_send_callback()`."]
609pub type nghttp2_before_frame_send_callback = ::std::option::Option<
610 unsafe extern "C" fn(
611 session: *mut nghttp2_session,
612 frame: *const nghttp2_frame,
613 user_data: *mut ::std::os::raw::c_void,
614 ) -> ::std::os::raw::c_int,
615>;
616#[doc = " @functypedef\n\n Callback function invoked after the frame |frame| is sent. The\n |user_data| pointer is the third argument passed in to the call to\n `nghttp2_session_client_new()` or `nghttp2_session_server_new()`.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero is returned, it is treated as fatal error and\n `nghttp2_session_send()` and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_frame_send_callback()`."]
617pub type nghttp2_on_frame_send_callback = ::std::option::Option<
618 unsafe extern "C" fn(
619 session: *mut nghttp2_session,
620 frame: *const nghttp2_frame,
621 user_data: *mut ::std::os::raw::c_void,
622 ) -> ::std::os::raw::c_int,
623>;
624#[doc = " @functypedef\n\n Callback function invoked after the non-DATA frame |frame| is not\n sent because of the error. The error is indicated by the\n |lib_error_code|, which is one of the values defined in\n :type:`nghttp2_error`. The |user_data| pointer is the third\n argument passed in to the call to `nghttp2_session_client_new()` or\n `nghttp2_session_server_new()`.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero is returned, it is treated as fatal error and\n `nghttp2_session_send()` and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n `nghttp2_session_get_stream_user_data()` can be used to get\n associated data.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_frame_not_send_callback()`."]
625pub type nghttp2_on_frame_not_send_callback = ::std::option::Option<
626 unsafe extern "C" fn(
627 session: *mut nghttp2_session,
628 frame: *const nghttp2_frame,
629 lib_error_code: ::std::os::raw::c_int,
630 user_data: *mut ::std::os::raw::c_void,
631 ) -> ::std::os::raw::c_int,
632>;
633#[doc = " @functypedef\n\n Callback function invoked when the stream |stream_id| is closed.\n The reason of closure is indicated by the |error_code|. The\n |error_code| is usually one of :enum:`nghttp2_error_code`, but that\n is not guaranteed. The stream_user_data, which was specified in\n `nghttp2_submit_request2()` or `nghttp2_submit_headers()`, is still\n available in this function. The |user_data| pointer is the third\n argument passed in to the call to `nghttp2_session_client_new()` or\n `nghttp2_session_server_new()`.\n\n This function is also called for a stream in reserved state.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero is returned, it is treated as fatal error and\n `nghttp2_session_recv()`, `nghttp2_session_mem_recv2()`,\n `nghttp2_session_send()`, and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_stream_close_callback()`."]
634pub type nghttp2_on_stream_close_callback = ::std::option::Option<
635 unsafe extern "C" fn(
636 session: *mut nghttp2_session,
637 stream_id: i32,
638 error_code: u32,
639 user_data: *mut ::std::os::raw::c_void,
640 ) -> ::std::os::raw::c_int,
641>;
642#[doc = " @functypedef\n\n Callback function invoked when the reception of header block in\n HEADERS or PUSH_PROMISE is started. Each header name/value pair\n will be emitted by :type:`nghttp2_on_header_callback`.\n\n The ``frame->hd.flags`` may not have\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_HEADERS` flag set, which\n indicates that one or more CONTINUATION frames are involved. But\n the application does not need to care about that because the header\n name/value pairs are emitted transparently regardless of\n CONTINUATION frames.\n\n The server applications probably create an object to store\n information about new stream if ``frame->hd.type ==\n NGHTTP2_HEADERS`` and ``frame->headers.cat ==\n NGHTTP2_HCAT_REQUEST``. If |session| is configured as server side,\n ``frame->headers.cat`` is either ``NGHTTP2_HCAT_REQUEST``\n containing request headers or ``NGHTTP2_HCAT_HEADERS`` containing\n trailer fields and never get PUSH_PROMISE in this callback.\n\n For the client applications, ``frame->hd.type`` is either\n ``NGHTTP2_HEADERS`` or ``NGHTTP2_PUSH_PROMISE``. In case of\n ``NGHTTP2_HEADERS``, ``frame->headers.cat ==\n NGHTTP2_HCAT_RESPONSE`` means that it is the first response\n headers, but it may be non-final response which is indicated by 1xx\n status code. In this case, there may be zero or more HEADERS frame\n with ``frame->headers.cat == NGHTTP2_HCAT_HEADERS`` which has\n non-final response code and finally client gets exactly one HEADERS\n frame with ``frame->headers.cat == NGHTTP2_HCAT_HEADERS``\n containing final response headers (non-1xx status code). The\n trailer fields also has ``frame->headers.cat ==\n NGHTTP2_HCAT_HEADERS`` which does not contain any status code.\n\n Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will\n close the stream (promised stream if frame is PUSH_PROMISE) by\n issuing RST_STREAM with\n :enum:`nghttp2_error_code.NGHTTP2_INTERNAL_ERROR`. In this case,\n :type:`nghttp2_on_header_callback` and\n :type:`nghttp2_on_frame_recv_callback` will not be invoked. If a\n different error code is desirable, use\n `nghttp2_submit_rst_stream()` with a desired error code and then\n return :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.\n Again, use ``frame->push_promise.promised_stream_id`` as stream_id\n parameter in `nghttp2_submit_rst_stream()` if frame is\n PUSH_PROMISE.\n\n The implementation of this function must return 0 if it succeeds.\n It can return\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` to\n reset the stream (promised stream if frame is PUSH_PROMISE). For\n critical errors, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n value is returned, it is treated as if\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` is returned. If\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` is returned,\n `nghttp2_session_mem_recv2()` function will immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_begin_headers_callback()`."]
643pub type nghttp2_on_begin_headers_callback = ::std::option::Option<
644 unsafe extern "C" fn(
645 session: *mut nghttp2_session,
646 frame: *const nghttp2_frame,
647 user_data: *mut ::std::os::raw::c_void,
648 ) -> ::std::os::raw::c_int,
649>;
650#[doc = " @functypedef\n\n Callback function invoked when a header name/value pair is received\n for the |frame|. The |name| of length |namelen| is header name.\n The |value| of length |valuelen| is header value. The |flags| is\n bitwise OR of one or more of :type:`nghttp2_nv_flag`.\n\n If :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_INDEX` is set in\n |flags|, the receiver must not index this name/value pair when\n forwarding it to the next hop. More specifically, \"Literal Header\n Field never Indexed\" representation must be used in HPACK encoding.\n\n When this callback is invoked, ``frame->hd.type`` is either\n :enum:`nghttp2_frame_type.NGHTTP2_HEADERS` or\n :enum:`nghttp2_frame_type.NGHTTP2_PUSH_PROMISE`. After all header\n name/value pairs are processed with this callback, and no error has\n been detected, :type:`nghttp2_on_frame_recv_callback` will be\n invoked. If there is an error in decompression,\n :type:`nghttp2_on_frame_recv_callback` for the |frame| will not be\n invoked.\n\n Both |name| and |value| are guaranteed to be NULL-terminated. The\n |namelen| and |valuelen| do not include terminal NULL. If\n `nghttp2_option_set_no_http_messaging()` is used with nonzero\n value, NULL character may be included in |name| or |value| before\n terminating NULL.\n\n Please note that unless `nghttp2_option_set_no_http_messaging()` is\n used, nghttp2 library does perform validation against the |name|\n and the |value| using `nghttp2_check_header_name()` and\n `nghttp2_check_header_value()`. In addition to this, nghttp2\n performs validation based on HTTP Messaging rule, which is briefly\n explained in :ref:`http-messaging` section.\n\n If the application uses `nghttp2_session_mem_recv2()`, it can\n return :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` to make\n `nghttp2_session_mem_recv2()` return without processing further\n input bytes. The memory pointed by |frame|, |name| and |value|\n parameters are retained until `nghttp2_session_mem_recv2()` or\n `nghttp2_session_recv()` is called. The application must retain\n the input bytes which was used to produce these parameters, because\n it may refer to the memory region included in the input bytes.\n\n Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` will\n close the stream (promised stream if frame is PUSH_PROMISE) by\n issuing RST_STREAM with\n :enum:`nghttp2_error_code.NGHTTP2_INTERNAL_ERROR`. In this case,\n :type:`nghttp2_on_header_callback` and\n :type:`nghttp2_on_frame_recv_callback` will not be invoked. If a\n different error code is desirable, use\n `nghttp2_submit_rst_stream()` with a desired error code and then\n return :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.\n Again, use ``frame->push_promise.promised_stream_id`` as stream_id\n parameter in `nghttp2_submit_rst_stream()` if frame is\n PUSH_PROMISE.\n\n The implementation of this function must return 0 if it succeeds.\n It may return :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` or\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. For\n other critical failures, it must return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n nonzero value is returned, it is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` is returned,\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_header_callback()`.\n\n .. warning::\n\n Application should properly limit the total buffer size to store\n incoming header fields. Without it, peer may send large number\n of header fields or large header fields to cause out of memory in\n local endpoint. Due to how HPACK works, peer can do this\n effectively without using much memory on their own."]
651pub type nghttp2_on_header_callback = ::std::option::Option<
652 unsafe extern "C" fn(
653 session: *mut nghttp2_session,
654 frame: *const nghttp2_frame,
655 name: *const u8,
656 namelen: usize,
657 value: *const u8,
658 valuelen: usize,
659 flags: u8,
660 user_data: *mut ::std::os::raw::c_void,
661 ) -> ::std::os::raw::c_int,
662>;
663#[doc = " @functypedef\n\n Callback function invoked when a header name/value pair is received\n for the |frame|. The |name| is header name. The |value| is header\n value. The |flags| is bitwise OR of one or more of\n :type:`nghttp2_nv_flag`.\n\n This callback behaves like :type:`nghttp2_on_header_callback`,\n except that |name| and |value| are stored in reference counted\n buffer. If application wishes to keep these references without\n copying them, use `nghttp2_rcbuf_incref()` to increment their\n reference count. It is the application's responsibility to call\n `nghttp2_rcbuf_decref()` if they called `nghttp2_rcbuf_incref()` so\n as not to leak memory. If the |session| is created by\n `nghttp2_session_server_new3()` or `nghttp2_session_client_new3()`,\n the function to free memory is the one belongs to the mem\n parameter. As long as this free function alives, |name| and\n |value| can live after |session| was destroyed."]
664pub type nghttp2_on_header_callback2 = ::std::option::Option<
665 unsafe extern "C" fn(
666 session: *mut nghttp2_session,
667 frame: *const nghttp2_frame,
668 name: *mut nghttp2_rcbuf,
669 value: *mut nghttp2_rcbuf,
670 flags: u8,
671 user_data: *mut ::std::os::raw::c_void,
672 ) -> ::std::os::raw::c_int,
673>;
674#[doc = " @functypedef\n\n Callback function invoked when an invalid header name/value pair is\n received for the |frame|.\n\n The parameter and behaviour are similar to\n :type:`nghttp2_on_header_callback`. The difference is that this\n callback is only invoked when an invalid header name/value pair is\n received which is treated as stream error if this callback returns\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE` and\n :type:`nghttp2_on_invalid_header_callback2` is not set. Only\n invalid regular header field are passed to this callback. In other\n words, invalid pseudo header field is not passed to this callback.\n Also header fields which includes upper cased latter are also\n treated as error without passing them to this callback.\n\n This callback is only considered if HTTP messaging validation is\n turned on (which is on by default, see\n `nghttp2_option_set_no_http_messaging()`).\n\n With this callback, application inspects the incoming invalid\n field, and it also can reset stream from this callback by returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. By\n default, the error code is\n :enum:`nghttp2_error_code.NGHTTP2_PROTOCOL_ERROR`. To change the\n error code, call `nghttp2_submit_rst_stream()` with the error code\n of choice in addition to returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`.\n\n If 0 is returned, the header field is ignored, and the stream is\n not reset."]
675pub type nghttp2_on_invalid_header_callback = ::std::option::Option<
676 unsafe extern "C" fn(
677 session: *mut nghttp2_session,
678 frame: *const nghttp2_frame,
679 name: *const u8,
680 namelen: usize,
681 value: *const u8,
682 valuelen: usize,
683 flags: u8,
684 user_data: *mut ::std::os::raw::c_void,
685 ) -> ::std::os::raw::c_int,
686>;
687#[doc = " @functypedef\n\n Callback function invoked when an invalid header name/value pair is\n received for the |frame|.\n\n The parameter and behaviour are similar to\n :type:`nghttp2_on_header_callback2`. The difference is that this\n callback is only invoked when an invalid header name/value pair is\n received which is silently ignored if neither this callback nor\n :type:`nghttp2_on_invalid_header_callback` is set. Only invalid\n regular header field are passed to this callback. In other words,\n invalid pseudo header field is not passed to this callback. Also\n header fields which includes upper cased latter are also treated as\n error without passing them to this callback.\n\n This callback is only considered if HTTP messaging validation is\n turned on (which is on by default, see\n `nghttp2_option_set_no_http_messaging()`).\n\n With this callback, application inspects the incoming invalid\n field, and it also can reset stream from this callback by returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`. By\n default, the error code is\n :enum:`nghttp2_error_code.NGHTTP2_INTERNAL_ERROR`. To change the\n error code, call `nghttp2_submit_rst_stream()` with the error code\n of choice in addition to returning\n :enum:`nghttp2_error.NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE`."]
688pub type nghttp2_on_invalid_header_callback2 = ::std::option::Option<
689 unsafe extern "C" fn(
690 session: *mut nghttp2_session,
691 frame: *const nghttp2_frame,
692 name: *mut nghttp2_rcbuf,
693 value: *mut nghttp2_rcbuf,
694 flags: u8,
695 user_data: *mut ::std::os::raw::c_void,
696 ) -> ::std::os::raw::c_int,
697>;
698#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_select_padding_callback2`\n instead.\n\n Callback function invoked when the library asks application how\n many padding bytes are required for the transmission of the\n |frame|. The application must choose the total length of payload\n including padded bytes in range [frame->hd.length, max_payloadlen],\n inclusive. Choosing number not in this range will be treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. Returning\n ``frame->hd.length`` means no padding is added. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will make\n `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions\n immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_select_padding_callback()`."]
699pub type nghttp2_select_padding_callback = ::std::option::Option<
700 unsafe extern "C" fn(
701 session: *mut nghttp2_session,
702 frame: *const nghttp2_frame,
703 max_payloadlen: usize,
704 user_data: *mut ::std::os::raw::c_void,
705 ) -> isize,
706>;
707#[doc = " @functypedef\n\n Callback function invoked when the library asks application how\n many padding bytes are required for the transmission of the\n |frame|. The application must choose the total length of payload\n including padded bytes in range [frame->hd.length, max_payloadlen],\n inclusive. Choosing number not in this range will be treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. Returning\n ``frame->hd.length`` means no padding is added. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will make\n `nghttp2_session_send()` and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_select_padding_callback2()`."]
708pub type nghttp2_select_padding_callback2 = ::std::option::Option<
709 unsafe extern "C" fn(
710 session: *mut nghttp2_session,
711 frame: *const nghttp2_frame,
712 max_payloadlen: usize,
713 user_data: *mut ::std::os::raw::c_void,
714 ) -> nghttp2_ssize,
715>;
716#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use\n :type:`nghttp2_data_source_read_length_callback2` instead.\n\n Callback function invoked when library wants to get max length of\n data to send data to the remote peer. The implementation of this\n function should return a value in the following range. [1,\n min(|session_remote_window_size|, |stream_remote_window_size|,\n |remote_max_frame_size|)]. If a value greater than this range is\n returned than the max allow value will be used. Returning a value\n smaller than this range is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. The\n |frame_type| is provided for future extensibility and identifies\n the type of frame (see :type:`nghttp2_frame_type`) for which to get\n the length for. Currently supported frame types are:\n :enum:`nghttp2_frame_type.NGHTTP2_DATA`.\n\n This callback can be used to control the length in bytes for which\n :type:`nghttp2_data_source_read_callback` is allowed to send to the\n remote endpoint. This callback is optional. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will signal the\n entire session failure.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_data_source_read_length_callback()`."]
717pub type nghttp2_data_source_read_length_callback = ::std::option::Option<
718 unsafe extern "C" fn(
719 session: *mut nghttp2_session,
720 frame_type: u8,
721 stream_id: i32,
722 session_remote_window_size: i32,
723 stream_remote_window_size: i32,
724 remote_max_frame_size: u32,
725 user_data: *mut ::std::os::raw::c_void,
726 ) -> isize,
727>;
728#[doc = " @functypedef\n\n Callback function invoked when library wants to get max length of\n data to send data to the remote peer. The implementation of this\n function should return a value in the following range. [1,\n min(|session_remote_window_size|, |stream_remote_window_size|,\n |remote_max_frame_size|)]. If a value greater than this range is\n returned than the max allow value will be used. Returning a value\n smaller than this range is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. The\n |frame_type| is provided for future extensibility and identifies\n the type of frame (see :type:`nghttp2_frame_type`) for which to get\n the length for. Currently supported frame types are:\n :enum:`nghttp2_frame_type.NGHTTP2_DATA`.\n\n This callback can be used to control the length in bytes for which\n :type:`nghttp2_data_source_read_callback` is allowed to send to the\n remote endpoint. This callback is optional. Returning\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE` will signal the\n entire session failure.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_data_source_read_length_callback2()`."]
729pub type nghttp2_data_source_read_length_callback2 = ::std::option::Option<
730 unsafe extern "C" fn(
731 session: *mut nghttp2_session,
732 frame_type: u8,
733 stream_id: i32,
734 session_remote_window_size: i32,
735 stream_remote_window_size: i32,
736 remote_max_frame_size: u32,
737 user_data: *mut ::std::os::raw::c_void,
738 ) -> nghttp2_ssize,
739>;
740#[doc = " @functypedef\n\n Callback function invoked when a frame header is received. The\n |hd| points to received frame header.\n\n Unlike :type:`nghttp2_on_frame_recv_callback`, this callback will\n also be called when frame header of CONTINUATION frame is received.\n\n If both :type:`nghttp2_on_begin_frame_callback` and\n :type:`nghttp2_on_begin_headers_callback` are set and HEADERS or\n PUSH_PROMISE is received, :type:`nghttp2_on_begin_frame_callback`\n will be called first.\n\n The implementation of this function must return 0 if it succeeds.\n If nonzero value is returned, it is treated as fatal error and\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n\n To set this callback to :type:`nghttp2_session_callbacks`, use\n `nghttp2_session_callbacks_set_on_begin_frame_callback()`."]
741pub type nghttp2_on_begin_frame_callback = ::std::option::Option<
742 unsafe extern "C" fn(
743 session: *mut nghttp2_session,
744 hd: *const nghttp2_frame_hd,
745 user_data: *mut ::std::os::raw::c_void,
746 ) -> ::std::os::raw::c_int,
747>;
748#[doc = " @functypedef\n\n Callback function invoked when chunk of extension frame payload is\n received. The |hd| points to frame header. The received\n chunk is |data| of length |len|.\n\n The implementation of this function must return 0 if it succeeds.\n\n To abort processing this extension frame, return\n :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL`.\n\n If fatal error occurred, application should return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n values are returned, currently they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`."]
749pub type nghttp2_on_extension_chunk_recv_callback = ::std::option::Option<
750 unsafe extern "C" fn(
751 session: *mut nghttp2_session,
752 hd: *const nghttp2_frame_hd,
753 data: *const u8,
754 len: usize,
755 user_data: *mut ::std::os::raw::c_void,
756 ) -> ::std::os::raw::c_int,
757>;
758#[doc = " @functypedef\n\n Callback function invoked when library asks the application to\n unpack extension payload from its wire format. The extension\n payload has been passed to the application using\n :type:`nghttp2_on_extension_chunk_recv_callback`. The frame header\n is already unpacked by the library and provided as |hd|.\n\n To receive extension frames, the application must tell desired\n extension frame type to the library using\n `nghttp2_option_set_user_recv_extension_type()`.\n\n The implementation of this function may store the pointer to the\n created object as a result of unpacking in |*payload|, and returns\n 0. The pointer stored in |*payload| is opaque to the library, and\n the library does not own its pointer. |*payload| is initialized as\n ``NULL``. The |*payload| is available as ``frame->ext.payload`` in\n :type:`nghttp2_on_frame_recv_callback`. Therefore if application\n can free that memory inside :type:`nghttp2_on_frame_recv_callback`\n callback. Of course, application has a liberty not to use\n |*payload|, and do its own mechanism to process extension frames.\n\n To abort processing this extension frame, return\n :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL`.\n\n If fatal error occurred, application should return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,\n `nghttp2_session_recv()` and `nghttp2_session_mem_recv2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n values are returned, currently they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`."]
759pub type nghttp2_unpack_extension_callback = ::std::option::Option<
760 unsafe extern "C" fn(
761 session: *mut nghttp2_session,
762 payload: *mut *mut ::std::os::raw::c_void,
763 hd: *const nghttp2_frame_hd,
764 user_data: *mut ::std::os::raw::c_void,
765 ) -> ::std::os::raw::c_int,
766>;
767#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_pack_extension_callback2`\n instead.\n\n Callback function invoked when library asks the application to pack\n extension payload in its wire format. The frame header will be\n packed by library. Application must pack payload only.\n ``frame->ext.payload`` is the object passed to\n `nghttp2_submit_extension()` as payload parameter. Application\n must pack extension payload to the |buf| of its capacity |len|\n bytes. The |len| is at least 16KiB.\n\n The implementation of this function should return the number of\n bytes written into |buf| when it succeeds.\n\n To abort processing this extension frame, return\n :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL`, and\n :type:`nghttp2_on_frame_not_send_callback` will be invoked.\n\n If fatal error occurred, application should return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,\n `nghttp2_session_send()` and `nghttp2_session_mem_send()` functions\n immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n values are returned, currently they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the return\n value is strictly larger than |len|, it is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`."]
768pub type nghttp2_pack_extension_callback = ::std::option::Option<
769 unsafe extern "C" fn(
770 session: *mut nghttp2_session,
771 buf: *mut u8,
772 len: usize,
773 frame: *const nghttp2_frame,
774 user_data: *mut ::std::os::raw::c_void,
775 ) -> isize,
776>;
777#[doc = " @functypedef\n\n Callback function invoked when library asks the application to pack\n extension payload in its wire format. The frame header will be\n packed by library. Application must pack payload only.\n ``frame->ext.payload`` is the object passed to\n `nghttp2_submit_extension()` as payload parameter. Application\n must pack extension payload to the |buf| of its capacity |len|\n bytes. The |len| is at least 16KiB.\n\n The implementation of this function should return the number of\n bytes written into |buf| when it succeeds.\n\n To abort processing this extension frame, return\n :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL`, and\n :type:`nghttp2_on_frame_not_send_callback` will be invoked.\n\n If fatal error occurred, application should return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. In this case,\n `nghttp2_session_send()` and `nghttp2_session_mem_send2()`\n functions immediately return\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the other\n values are returned, currently they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. If the return\n value is strictly larger than |len|, it is treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`."]
778pub type nghttp2_pack_extension_callback2 = ::std::option::Option<
779 unsafe extern "C" fn(
780 session: *mut nghttp2_session,
781 buf: *mut u8,
782 len: usize,
783 frame: *const nghttp2_frame,
784 user_data: *mut ::std::os::raw::c_void,
785 ) -> nghttp2_ssize,
786>;
787#[doc = " @functypedef\n\n .. warning::\n\n Deprecated. Use :type:`nghttp2_error_callback2` instead.\n\n Callback function invoked when library provides the error message\n intended for human consumption. This callback is solely for\n debugging purpose. The |msg| is typically NULL-terminated string\n of length |len|. |len| does not include the sentinel NULL\n character.\n\n The format of error message may change between nghttp2 library\n versions. The application should not depend on the particular\n format.\n\n Normally, application should return 0 from this callback. If fatal\n error occurred while doing something in this callback, application\n should return :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n In this case, library will return immediately with return value\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. Currently, if\n nonzero value is returned from this callback, they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`, but application\n should not rely on this details."]
788pub type nghttp2_error_callback = ::std::option::Option<
789 unsafe extern "C" fn(
790 session: *mut nghttp2_session,
791 msg: *const ::std::os::raw::c_char,
792 len: usize,
793 user_data: *mut ::std::os::raw::c_void,
794 ) -> ::std::os::raw::c_int,
795>;
796#[doc = " @functypedef\n\n Callback function invoked when library provides the error code, and\n message. This callback is solely for debugging purpose.\n |lib_error_code| is one of error code defined in\n :enum:`nghttp2_error`. The |msg| is typically NULL-terminated\n string of length |len|, and intended for human consumption. |len|\n does not include the sentinel NULL character.\n\n The format of error message may change between nghttp2 library\n versions. The application should not depend on the particular\n format.\n\n Normally, application should return 0 from this callback. If fatal\n error occurred while doing something in this callback, application\n should return :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`.\n In this case, library will return immediately with return value\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`. Currently, if\n nonzero value is returned from this callback, they are treated as\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`, but application\n should not rely on this details."]
797pub type nghttp2_error_callback2 = ::std::option::Option<
798 unsafe extern "C" fn(
799 session: *mut nghttp2_session,
800 lib_error_code: ::std::os::raw::c_int,
801 msg: *const ::std::os::raw::c_char,
802 len: usize,
803 user_data: *mut ::std::os::raw::c_void,
804 ) -> ::std::os::raw::c_int,
805>;
806#[doc = " @functypedef\n\n Callback function invoked when unpredictable data of |destlen|\n bytes are needed. The implementation must write unpredictable data\n of |destlen| bytes into the buffer pointed by |dest|."]
807pub type nghttp2_rand_callback =
808 ::std::option::Option<unsafe extern "C" fn(dest: *mut u8, destlen: usize)>;
809#[repr(C)]
810#[derive(Debug, Copy, Clone)]
811pub struct nghttp2_session_callbacks {
812 _unused: [u8; 0],
813}
814unsafe extern "C" {
815 #[doc = " @function\n\n Initializes |*callbacks_ptr| with NULL values.\n\n The initialized object can be used when initializing multiple\n :type:`nghttp2_session` objects.\n\n When the application finished using this object, it can use\n `nghttp2_session_callbacks_del()` to free its memory.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
816 pub fn nghttp2_session_callbacks_new(
817 callbacks_ptr: *mut *mut nghttp2_session_callbacks,
818 ) -> ::std::os::raw::c_int;
819}
820unsafe extern "C" {
821 #[doc = " @function\n\n Frees any resources allocated for |callbacks|. If |callbacks| is\n ``NULL``, this function does nothing."]
822 pub fn nghttp2_session_callbacks_del(
823 callbacks: *mut nghttp2_session_callbacks,
824 );
825}
826unsafe extern "C" {
827 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_session_callbacks_set_send_callback2()`\n with :type:`nghttp2_send_callback2` instead.\n\n Sets callback function invoked when a session wants to send data to\n the remote peer. This callback is not necessary if the application\n uses solely `nghttp2_session_mem_send()` to serialize data to\n transmit."]
828 pub fn nghttp2_session_callbacks_set_send_callback(
829 cbs: *mut nghttp2_session_callbacks,
830 send_callback: nghttp2_send_callback,
831 );
832}
833unsafe extern "C" {
834 #[doc = " @function\n\n Sets callback function invoked when a session wants to send data to\n the remote peer. This callback is not necessary if the application\n uses solely `nghttp2_session_mem_send2()` to serialize data to\n transmit."]
835 pub fn nghttp2_session_callbacks_set_send_callback2(
836 cbs: *mut nghttp2_session_callbacks,
837 send_callback: nghttp2_send_callback2,
838 );
839}
840unsafe extern "C" {
841 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_session_callbacks_set_recv_callback2()`\n with :type:`nghttp2_recv_callback2` instead.\n\n Sets callback function invoked when the a session wants to receive\n data from the remote peer. This callback is not necessary if the\n application uses solely `nghttp2_session_mem_recv()` to process\n received data."]
842 pub fn nghttp2_session_callbacks_set_recv_callback(
843 cbs: *mut nghttp2_session_callbacks,
844 recv_callback: nghttp2_recv_callback,
845 );
846}
847unsafe extern "C" {
848 #[doc = " @function\n\n Sets callback function invoked when the a session wants to receive\n data from the remote peer. This callback is not necessary if the\n application uses solely `nghttp2_session_mem_recv2()` to process\n received data."]
849 pub fn nghttp2_session_callbacks_set_recv_callback2(
850 cbs: *mut nghttp2_session_callbacks,
851 recv_callback: nghttp2_recv_callback2,
852 );
853}
854unsafe extern "C" {
855 #[doc = " @function\n\n Sets callback function invoked by `nghttp2_session_recv()` and\n `nghttp2_session_mem_recv2()` when a frame is received."]
856 pub fn nghttp2_session_callbacks_set_on_frame_recv_callback(
857 cbs: *mut nghttp2_session_callbacks,
858 on_frame_recv_callback: nghttp2_on_frame_recv_callback,
859 );
860}
861unsafe extern "C" {
862 #[doc = " @function\n\n Sets callback function invoked by `nghttp2_session_recv()` and\n `nghttp2_session_mem_recv2()` when an invalid non-DATA frame is\n received."]
863 pub fn nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(
864 cbs: *mut nghttp2_session_callbacks,
865 on_invalid_frame_recv_callback: nghttp2_on_invalid_frame_recv_callback,
866 );
867}
868unsafe extern "C" {
869 #[doc = " @function\n\n Sets callback function invoked when a chunk of data in DATA frame\n is received."]
870 pub fn nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
871 cbs: *mut nghttp2_session_callbacks,
872 on_data_chunk_recv_callback: nghttp2_on_data_chunk_recv_callback,
873 );
874}
875unsafe extern "C" {
876 #[doc = " @function\n\n Sets callback function invoked before a non-DATA frame is sent."]
877 pub fn nghttp2_session_callbacks_set_before_frame_send_callback(
878 cbs: *mut nghttp2_session_callbacks,
879 before_frame_send_callback: nghttp2_before_frame_send_callback,
880 );
881}
882unsafe extern "C" {
883 #[doc = " @function\n\n Sets callback function invoked after a frame is sent."]
884 pub fn nghttp2_session_callbacks_set_on_frame_send_callback(
885 cbs: *mut nghttp2_session_callbacks,
886 on_frame_send_callback: nghttp2_on_frame_send_callback,
887 );
888}
889unsafe extern "C" {
890 #[doc = " @function\n\n Sets callback function invoked when a non-DATA frame is not sent\n because of an error."]
891 pub fn nghttp2_session_callbacks_set_on_frame_not_send_callback(
892 cbs: *mut nghttp2_session_callbacks,
893 on_frame_not_send_callback: nghttp2_on_frame_not_send_callback,
894 );
895}
896unsafe extern "C" {
897 #[doc = " @function\n\n Sets callback function invoked when the stream is closed."]
898 pub fn nghttp2_session_callbacks_set_on_stream_close_callback(
899 cbs: *mut nghttp2_session_callbacks,
900 on_stream_close_callback: nghttp2_on_stream_close_callback,
901 );
902}
903unsafe extern "C" {
904 #[doc = " @function\n\n Sets callback function invoked when the reception of header block\n in HEADERS or PUSH_PROMISE is started."]
905 pub fn nghttp2_session_callbacks_set_on_begin_headers_callback(
906 cbs: *mut nghttp2_session_callbacks,
907 on_begin_headers_callback: nghttp2_on_begin_headers_callback,
908 );
909}
910unsafe extern "C" {
911 #[doc = " @function\n\n Sets callback function invoked when a header name/value pair is\n received. If both\n `nghttp2_session_callbacks_set_on_header_callback()` and\n `nghttp2_session_callbacks_set_on_header_callback2()` are used to\n set callbacks, the latter has the precedence."]
912 pub fn nghttp2_session_callbacks_set_on_header_callback(
913 cbs: *mut nghttp2_session_callbacks,
914 on_header_callback: nghttp2_on_header_callback,
915 );
916}
917unsafe extern "C" {
918 #[doc = " @function\n\n Sets callback function invoked when a header name/value pair is\n received."]
919 pub fn nghttp2_session_callbacks_set_on_header_callback2(
920 cbs: *mut nghttp2_session_callbacks,
921 on_header_callback2: nghttp2_on_header_callback2,
922 );
923}
924unsafe extern "C" {
925 #[doc = " @function\n\n Sets callback function invoked when an invalid header name/value\n pair is received. If both\n `nghttp2_session_callbacks_set_on_invalid_header_callback()` and\n `nghttp2_session_callbacks_set_on_invalid_header_callback2()` are\n used to set callbacks, the latter takes the precedence."]
926 pub fn nghttp2_session_callbacks_set_on_invalid_header_callback(
927 cbs: *mut nghttp2_session_callbacks,
928 on_invalid_header_callback: nghttp2_on_invalid_header_callback,
929 );
930}
931unsafe extern "C" {
932 #[doc = " @function\n\n Sets callback function invoked when an invalid header name/value\n pair is received."]
933 pub fn nghttp2_session_callbacks_set_on_invalid_header_callback2(
934 cbs: *mut nghttp2_session_callbacks,
935 on_invalid_header_callback2: nghttp2_on_invalid_header_callback2,
936 );
937}
938unsafe extern "C" {
939 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use\n `nghttp2_session_callbacks_set_select_padding_callback2()` with\n :type:`nghttp2_select_padding_callback2` instead.\n\n Sets callback function invoked when the library asks application\n how many padding bytes are required for the transmission of the\n given frame."]
940 pub fn nghttp2_session_callbacks_set_select_padding_callback(
941 cbs: *mut nghttp2_session_callbacks,
942 select_padding_callback: nghttp2_select_padding_callback,
943 );
944}
945unsafe extern "C" {
946 #[doc = " @function\n\n Sets callback function invoked when the library asks application\n how many padding bytes are required for the transmission of the\n given frame."]
947 pub fn nghttp2_session_callbacks_set_select_padding_callback2(
948 cbs: *mut nghttp2_session_callbacks,
949 select_padding_callback: nghttp2_select_padding_callback2,
950 );
951}
952unsafe extern "C" {
953 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use\n `nghttp2_session_callbacks_set_data_source_read_length_callback2()`\n with :type:`nghttp2_data_source_read_length_callback2` instead.\n\n Sets callback function determine the length allowed in\n :type:`nghttp2_data_source_read_callback`."]
954 pub fn nghttp2_session_callbacks_set_data_source_read_length_callback(
955 cbs: *mut nghttp2_session_callbacks,
956 data_source_read_length_callback: nghttp2_data_source_read_length_callback,
957 );
958}
959unsafe extern "C" {
960 #[doc = " @function\n\n Sets callback function determine the length allowed in\n :type:`nghttp2_data_source_read_callback2`."]
961 pub fn nghttp2_session_callbacks_set_data_source_read_length_callback2(
962 cbs: *mut nghttp2_session_callbacks,
963 data_source_read_length_callback: nghttp2_data_source_read_length_callback2,
964 );
965}
966unsafe extern "C" {
967 #[doc = " @function\n\n Sets callback function invoked when a frame header is received."]
968 pub fn nghttp2_session_callbacks_set_on_begin_frame_callback(
969 cbs: *mut nghttp2_session_callbacks,
970 on_begin_frame_callback: nghttp2_on_begin_frame_callback,
971 );
972}
973unsafe extern "C" {
974 #[doc = " @function\n\n Sets callback function invoked when\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_COPY` is used in\n :type:`nghttp2_data_source_read_callback2` to avoid data copy."]
975 pub fn nghttp2_session_callbacks_set_send_data_callback(
976 cbs: *mut nghttp2_session_callbacks,
977 send_data_callback: nghttp2_send_data_callback,
978 );
979}
980unsafe extern "C" {
981 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use\n `nghttp2_session_callbacks_set_pack_extension_callback2()` with\n :type:`nghttp2_pack_extension_callback2` instead.\n\n Sets callback function invoked when the library asks the\n application to pack extension frame payload in wire format."]
982 pub fn nghttp2_session_callbacks_set_pack_extension_callback(
983 cbs: *mut nghttp2_session_callbacks,
984 pack_extension_callback: nghttp2_pack_extension_callback,
985 );
986}
987unsafe extern "C" {
988 #[doc = " @function\n\n Sets callback function invoked when the library asks the\n application to pack extension frame payload in wire format."]
989 pub fn nghttp2_session_callbacks_set_pack_extension_callback2(
990 cbs: *mut nghttp2_session_callbacks,
991 pack_extension_callback: nghttp2_pack_extension_callback2,
992 );
993}
994unsafe extern "C" {
995 #[doc = " @function\n\n Sets callback function invoked when the library asks the\n application to unpack extension frame payload from wire format."]
996 pub fn nghttp2_session_callbacks_set_unpack_extension_callback(
997 cbs: *mut nghttp2_session_callbacks,
998 unpack_extension_callback: nghttp2_unpack_extension_callback,
999 );
1000}
1001unsafe extern "C" {
1002 #[doc = " @function\n\n Sets callback function invoked when chunk of extension frame\n payload is received."]
1003 pub fn nghttp2_session_callbacks_set_on_extension_chunk_recv_callback(
1004 cbs: *mut nghttp2_session_callbacks,
1005 on_extension_chunk_recv_callback: nghttp2_on_extension_chunk_recv_callback,
1006 );
1007}
1008unsafe extern "C" {
1009 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use\n `nghttp2_session_callbacks_set_error_callback2()` with\n :type:`nghttp2_error_callback2` instead.\n\n Sets callback function invoked when library tells error message to\n the application.\n\n If both :type:`nghttp2_error_callback` and\n :type:`nghttp2_error_callback2` are set, the latter takes\n precedence."]
1010 pub fn nghttp2_session_callbacks_set_error_callback(
1011 cbs: *mut nghttp2_session_callbacks,
1012 error_callback: nghttp2_error_callback,
1013 );
1014}
1015unsafe extern "C" {
1016 #[doc = " @function\n\n Sets callback function invoked when library tells error code, and\n message to the application.\n\n If both :type:`nghttp2_error_callback` and\n :type:`nghttp2_error_callback2` are set, the latter takes\n precedence."]
1017 pub fn nghttp2_session_callbacks_set_error_callback2(
1018 cbs: *mut nghttp2_session_callbacks,
1019 error_callback2: nghttp2_error_callback2,
1020 );
1021}
1022unsafe extern "C" {
1023 #[doc = " @function\n\n Sets callback function invoked when unpredictable data is needed.\n Although this callback is optional due to the backward\n compatibility, it is recommended to specify it to harden the\n runtime behavior against suspicious activities of a remote\n endpoint."]
1024 pub fn nghttp2_session_callbacks_set_rand_callback(
1025 cbs: *mut nghttp2_session_callbacks,
1026 rand_callback: nghttp2_rand_callback,
1027 );
1028}
1029#[doc = " @functypedef\n\n Custom memory allocator to replace malloc(). The |mem_user_data|\n is the mem_user_data member of :type:`nghttp2_mem` structure."]
1030pub type nghttp2_malloc = ::std::option::Option<
1031 unsafe extern "C" fn(
1032 size: usize,
1033 mem_user_data: *mut ::std::os::raw::c_void,
1034 ) -> *mut ::std::os::raw::c_void,
1035>;
1036#[doc = " @functypedef\n\n Custom memory allocator to replace free(). The |mem_user_data| is\n the mem_user_data member of :type:`nghttp2_mem` structure."]
1037pub type nghttp2_free = ::std::option::Option<
1038 unsafe extern "C" fn(
1039 ptr: *mut ::std::os::raw::c_void,
1040 mem_user_data: *mut ::std::os::raw::c_void,
1041 ),
1042>;
1043#[doc = " @functypedef\n\n Custom memory allocator to replace calloc(). The |mem_user_data|\n is the mem_user_data member of :type:`nghttp2_mem` structure."]
1044pub type nghttp2_calloc = ::std::option::Option<
1045 unsafe extern "C" fn(
1046 nmemb: usize,
1047 size: usize,
1048 mem_user_data: *mut ::std::os::raw::c_void,
1049 ) -> *mut ::std::os::raw::c_void,
1050>;
1051#[doc = " @functypedef\n\n Custom memory allocator to replace realloc(). The |mem_user_data|\n is the mem_user_data member of :type:`nghttp2_mem` structure."]
1052pub type nghttp2_realloc = ::std::option::Option<
1053 unsafe extern "C" fn(
1054 ptr: *mut ::std::os::raw::c_void,
1055 size: usize,
1056 mem_user_data: *mut ::std::os::raw::c_void,
1057 ) -> *mut ::std::os::raw::c_void,
1058>;
1059#[doc = " @struct\n\n Custom memory allocator functions and user defined pointer. The\n |mem_user_data| member is passed to each allocator function. This\n can be used, for example, to achieve per-session memory pool.\n\n In the following example code, ``my_malloc``, ``my_free``,\n ``my_calloc`` and ``my_realloc`` are the replacement of the\n standard allocators ``malloc``, ``free``, ``calloc`` and\n ``realloc`` respectively::\n\n void *my_malloc_cb(size_t size, void *mem_user_data) {\n return my_malloc(size);\n }\n\n void my_free_cb(void *ptr, void *mem_user_data) { my_free(ptr); }\n\n void *my_calloc_cb(size_t nmemb, size_t size, void *mem_user_data) {\n return my_calloc(nmemb, size);\n }\n\n void *my_realloc_cb(void *ptr, size_t size, void *mem_user_data) {\n return my_realloc(ptr, size);\n }\n\n void session_new() {\n nghttp2_session *session;\n nghttp2_session_callbacks *callbacks;\n nghttp2_mem mem = {NULL, my_malloc_cb, my_free_cb, my_calloc_cb,\n my_realloc_cb};\n\n ...\n\n nghttp2_session_client_new3(&session, callbacks, NULL, NULL, &mem);\n\n ...\n }"]
1060#[repr(C)]
1061#[derive(Debug, Copy, Clone)]
1062pub struct nghttp2_mem {
1063 #[doc = " An arbitrary user supplied data. This is passed to each\n allocator function."]
1064 pub mem_user_data: *mut ::std::os::raw::c_void,
1065 #[doc = " Custom allocator function to replace malloc()."]
1066 pub malloc: nghttp2_malloc,
1067 #[doc = " Custom allocator function to replace free()."]
1068 pub free: nghttp2_free,
1069 #[doc = " Custom allocator function to replace calloc()."]
1070 pub calloc: nghttp2_calloc,
1071 #[doc = " Custom allocator function to replace realloc()."]
1072 pub realloc: nghttp2_realloc,
1073}
1074#[repr(C)]
1075#[derive(Debug, Copy, Clone)]
1076pub struct nghttp2_option {
1077 _unused: [u8; 0],
1078}
1079unsafe extern "C" {
1080 #[doc = " @function\n\n Initializes |*option_ptr| with default values.\n\n When the application finished using this object, it can use\n `nghttp2_option_del()` to free its memory.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1081 pub fn nghttp2_option_new(
1082 option_ptr: *mut *mut nghttp2_option,
1083 ) -> ::std::os::raw::c_int;
1084}
1085unsafe extern "C" {
1086 #[doc = " @function\n\n Frees any resources allocated for |option|. If |option| is\n ``NULL``, this function does nothing."]
1087 pub fn nghttp2_option_del(option: *mut nghttp2_option);
1088}
1089unsafe extern "C" {
1090 #[doc = " @function\n\n This option prevents the library from sending WINDOW_UPDATE for a\n connection automatically. If this option is set to nonzero, the\n library won't send WINDOW_UPDATE for DATA until application calls\n `nghttp2_session_consume()` to indicate the consumed amount of\n data. Don't use `nghttp2_submit_window_update()` for this purpose.\n By default, this option is set to zero."]
1091 pub fn nghttp2_option_set_no_auto_window_update(
1092 option: *mut nghttp2_option,
1093 val: ::std::os::raw::c_int,
1094 );
1095}
1096unsafe extern "C" {
1097 #[doc = " @function\n\n This option sets the SETTINGS_MAX_CONCURRENT_STREAMS value of\n remote endpoint as if it is received in SETTINGS frame. Without\n specifying this option, the maximum number of outgoing concurrent\n streams is initially limited to 100 to avoid issues when the local\n endpoint submits lots of requests before receiving initial SETTINGS\n frame from the remote endpoint, since sending them at once to the\n remote endpoint could lead to rejection of some of the requests.\n This value will be overwritten when the local endpoint receives\n initial SETTINGS frame from the remote endpoint, either to the\n value advertised in SETTINGS_MAX_CONCURRENT_STREAMS or to the\n default value (unlimited) if none was advertised."]
1098 pub fn nghttp2_option_set_peer_max_concurrent_streams(
1099 option: *mut nghttp2_option,
1100 val: u32,
1101 );
1102}
1103unsafe extern "C" {
1104 #[doc = " @function\n\n By default, nghttp2 library, if configured as server, requires\n first 24 bytes of client magic byte string (MAGIC). In most cases,\n this will simplify the implementation of server. But sometimes\n server may want to detect the application protocol based on first\n few bytes on clear text communication.\n\n If this option is used with nonzero |val|, nghttp2 library does not\n handle MAGIC. It still checks following SETTINGS frame. This\n means that applications should deal with MAGIC by themselves.\n\n If this option is not used or used with zero value, if MAGIC does\n not match :macro:`NGHTTP2_CLIENT_MAGIC`, `nghttp2_session_recv()`\n and `nghttp2_session_mem_recv2()` will return error\n :enum:`nghttp2_error.NGHTTP2_ERR_BAD_CLIENT_MAGIC`, which is fatal\n error."]
1105 pub fn nghttp2_option_set_no_recv_client_magic(
1106 option: *mut nghttp2_option,
1107 val: ::std::os::raw::c_int,
1108 );
1109}
1110unsafe extern "C" {
1111 #[doc = " @function\n\n By default, nghttp2 library enforces subset of HTTP Messaging rules\n described in `HTTP/2 specification, section 8\n <https://tools.ietf.org/html/rfc7540#section-8>`_. See\n :ref:`http-messaging` section for details. For those applications\n who use nghttp2 library as non-HTTP use, give nonzero to |val| to\n disable this enforcement. Please note that disabling this feature\n does not change the fundamental client and server model of HTTP.\n That is, even if the validation is disabled, only client can send\n requests."]
1112 pub fn nghttp2_option_set_no_http_messaging(
1113 option: *mut nghttp2_option,
1114 val: ::std::os::raw::c_int,
1115 );
1116}
1117unsafe extern "C" {
1118 #[doc = " @function\n\n RFC 7540 does not enforce any limit on the number of incoming\n reserved streams (in RFC 7540 terms, streams in reserved (remote)\n state). This only affects client side, since only server can push\n streams. Malicious server can push arbitrary number of streams,\n and make client's memory exhausted. This option can set the\n maximum number of such incoming streams to avoid possible memory\n exhaustion. If this option is set, and pushed streams are\n automatically closed on reception, without calling user provided\n callback, if they exceed the given limit. The default value is\n 200. If session is configured as server side, this option has no\n effect. Server can control the number of streams to push."]
1119 pub fn nghttp2_option_set_max_reserved_remote_streams(
1120 option: *mut nghttp2_option,
1121 val: u32,
1122 );
1123}
1124unsafe extern "C" {
1125 #[doc = " @function\n\n Sets extension frame type the application is willing to handle with\n user defined callbacks (see\n :type:`nghttp2_on_extension_chunk_recv_callback` and\n :type:`nghttp2_unpack_extension_callback`). The |type| is\n extension frame type, and must be strictly greater than 0x9.\n Otherwise, this function does nothing. The application can call\n this function multiple times to set more than one frame type to\n receive. The application does not have to call this function if it\n just sends extension frames."]
1126 pub fn nghttp2_option_set_user_recv_extension_type(
1127 option: *mut nghttp2_option,
1128 type_: u8,
1129 );
1130}
1131unsafe extern "C" {
1132 #[doc = " @function\n\n Sets extension frame type the application is willing to receive\n using builtin handler. The |type| is the extension frame type to\n receive, and must be strictly greater than 0x9. Otherwise, this\n function does nothing. The application can call this function\n multiple times to set more than one frame type to receive. The\n application does not have to call this function if it just sends\n extension frames.\n\n If same frame type is passed to both\n `nghttp2_option_set_builtin_recv_extension_type()` and\n `nghttp2_option_set_user_recv_extension_type()`, the latter takes\n precedence."]
1133 pub fn nghttp2_option_set_builtin_recv_extension_type(
1134 option: *mut nghttp2_option,
1135 type_: u8,
1136 );
1137}
1138unsafe extern "C" {
1139 #[doc = " @function\n\n This option prevents the library from sending PING frame with ACK\n flag set automatically when PING frame without ACK flag set is\n received. If this option is set to nonzero, the library won't send\n PING frame with ACK flag set in the response for incoming PING\n frame. The application can send PING frame with ACK flag set using\n `nghttp2_submit_ping()` with :enum:`nghttp2_flag.NGHTTP2_FLAG_ACK`\n as flags parameter."]
1140 pub fn nghttp2_option_set_no_auto_ping_ack(
1141 option: *mut nghttp2_option,
1142 val: ::std::os::raw::c_int,
1143 );
1144}
1145unsafe extern "C" {
1146 #[doc = " @function\n\n This option sets the maximum length of header block (a set of\n header fields per one HEADERS frame) to send. The length of a\n given set of header fields is calculated using\n `nghttp2_hd_deflate_bound()`. The default value is 64KiB. If\n application attempts to send header fields larger than this limit,\n the transmission of the frame fails with error code\n :enum:`nghttp2_error.NGHTTP2_ERR_FRAME_SIZE_ERROR`."]
1147 pub fn nghttp2_option_set_max_send_header_block_length(
1148 option: *mut nghttp2_option,
1149 val: usize,
1150 );
1151}
1152unsafe extern "C" {
1153 #[doc = " @function\n\n This option sets the maximum dynamic table size for deflating\n header fields. The default value is 4KiB. In HTTP/2, receiver of\n deflated header block can specify maximum dynamic table size. The\n actual maximum size is the minimum of the size receiver specified\n and this option value."]
1154 pub fn nghttp2_option_set_max_deflate_dynamic_table_size(
1155 option: *mut nghttp2_option,
1156 val: usize,
1157 );
1158}
1159unsafe extern "C" {
1160 #[doc = " @function\n\n .. warning::\n\n Deprecated. Closed streams are not retained anymore.\n\n This function works as before, but it does not take any effect\n against :type:`nghttp2_session`."]
1161 pub fn nghttp2_option_set_no_closed_streams(
1162 option: *mut nghttp2_option,
1163 val: ::std::os::raw::c_int,
1164 );
1165}
1166unsafe extern "C" {
1167 #[doc = " @function\n\n This function sets the maximum number of outgoing SETTINGS ACK and\n PING ACK frames retained in :type:`nghttp2_session` object. If\n more than those frames are retained, the peer is considered to be\n misbehaving and session will be closed. The default value is 1000."]
1168 pub fn nghttp2_option_set_max_outbound_ack(
1169 option: *mut nghttp2_option,
1170 val: usize,
1171 );
1172}
1173unsafe extern "C" {
1174 #[doc = " @function\n\n This function sets the maximum number of SETTINGS entries per\n SETTINGS frame that will be accepted. If more than those entries\n are received, the peer is considered to be misbehaving and session\n will be closed. The default value is 32."]
1175 pub fn nghttp2_option_set_max_settings(
1176 option: *mut nghttp2_option,
1177 val: usize,
1178 );
1179}
1180unsafe extern "C" {
1181 #[doc = " @function\n\n .. warning::\n Deprecated. :rfc:`7540` priorities have been removed.\n\n This function works as before, but it does not take any effect\n against :type:`nghttp2_session`."]
1182 pub fn nghttp2_option_set_server_fallback_rfc7540_priorities(
1183 option: *mut nghttp2_option,
1184 val: ::std::os::raw::c_int,
1185 );
1186}
1187unsafe extern "C" {
1188 #[doc = " @function\n\n This option, if set to nonzero, turns off RFC 9113 leading and\n trailing white spaces validation against HTTP field value. Some\n important fields, such as HTTP/2 pseudo header fields, are\n validated more strictly and this option does not apply to them."]
1189 pub fn nghttp2_option_set_no_rfc9113_leading_and_trailing_ws_validation(
1190 option: *mut nghttp2_option,
1191 val: ::std::os::raw::c_int,
1192 );
1193}
1194unsafe extern "C" {
1195 #[doc = " @function\n\n This function sets the rate limit for the incoming stream reset\n (RST_STREAM frame). It is server use only. It is a token-bucket\n based rate limiter. |burst| specifies the number of tokens that is\n initially available. The maximum number of tokens is capped to\n this value. |rate| specifies the number of tokens that are\n regenerated per second. An incoming RST_STREAM consumes one token.\n If there is no token available, GOAWAY is sent to tear down the\n connection. |burst| and |rate| default to 1000 and 33\n respectively."]
1196 pub fn nghttp2_option_set_stream_reset_rate_limit(
1197 option: *mut nghttp2_option,
1198 burst: u64,
1199 rate: u64,
1200 );
1201}
1202unsafe extern "C" {
1203 #[doc = " @function\n\n This function sets the maximum number of CONTINUATION frames\n following an incoming HEADER frame. If more than those frames are\n received, the remote endpoint is considered to be misbehaving and\n session will be closed. The default value is 8."]
1204 pub fn nghttp2_option_set_max_continuations(
1205 option: *mut nghttp2_option,
1206 val: usize,
1207 );
1208}
1209unsafe extern "C" {
1210 #[doc = " @function\n\n This function sets the rate limit for the \"glitches\", the\n suspicious activities from a remote endpoint. It is a token-bucket\n based rate limiter. |burst| specifies the number of tokens that is\n initially available. The maximum number of tokens is capped to\n this value. |rate| specifies the number of tokens that are\n regenerated per second. When a suspicious activity is detected,\n some amount of tokens are consumed. If there is no token\n available, GOAWAY is sent to tear down the connection. |burst| and\n |rate| default to 1000 and 33 respectively."]
1211 pub fn nghttp2_option_set_glitch_rate_limit(
1212 option: *mut nghttp2_option,
1213 burst: u64,
1214 rate: u64,
1215 );
1216}
1217unsafe extern "C" {
1218 #[doc = " @function\n\n Initializes |*session_ptr| for client use. The all members of\n |callbacks| are copied to |*session_ptr|. Therefore |*session_ptr|\n does not store |callbacks|. The |user_data| is an arbitrary user\n supplied data, which will be passed to the callback functions.\n\n The :type:`nghttp2_send_callback2` must be specified. If the\n application code uses `nghttp2_session_recv()`, the\n :type:`nghttp2_recv_callback` must be specified. The other members\n of |callbacks| can be ``NULL``.\n\n If this function fails, |*session_ptr| is left untouched.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1219 pub fn nghttp2_session_client_new(
1220 session_ptr: *mut *mut nghttp2_session,
1221 callbacks: *const nghttp2_session_callbacks,
1222 user_data: *mut ::std::os::raw::c_void,
1223 ) -> ::std::os::raw::c_int;
1224}
1225unsafe extern "C" {
1226 #[doc = " @function\n\n Initializes |*session_ptr| for server use. The all members of\n |callbacks| are copied to |*session_ptr|. Therefore |*session_ptr|\n does not store |callbacks|. The |user_data| is an arbitrary user\n supplied data, which will be passed to the callback functions.\n\n The :type:`nghttp2_send_callback2` must be specified. If the\n application code uses `nghttp2_session_recv()`, the\n :type:`nghttp2_recv_callback` must be specified. The other members\n of |callbacks| can be ``NULL``.\n\n If this function fails, |*session_ptr| is left untouched.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1227 pub fn nghttp2_session_server_new(
1228 session_ptr: *mut *mut nghttp2_session,
1229 callbacks: *const nghttp2_session_callbacks,
1230 user_data: *mut ::std::os::raw::c_void,
1231 ) -> ::std::os::raw::c_int;
1232}
1233unsafe extern "C" {
1234 #[doc = " @function\n\n Like `nghttp2_session_client_new()`, but with additional options\n specified in the |option|.\n\n The |option| can be ``NULL`` and the call is equivalent to\n `nghttp2_session_client_new()`.\n\n This function does not take ownership |option|. The application is\n responsible for freeing |option| if it finishes using the object.\n\n The library code does not refer to |option| after this function\n returns.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1235 pub fn nghttp2_session_client_new2(
1236 session_ptr: *mut *mut nghttp2_session,
1237 callbacks: *const nghttp2_session_callbacks,
1238 user_data: *mut ::std::os::raw::c_void,
1239 option: *const nghttp2_option,
1240 ) -> ::std::os::raw::c_int;
1241}
1242unsafe extern "C" {
1243 #[doc = " @function\n\n Like `nghttp2_session_server_new()`, but with additional options\n specified in the |option|.\n\n The |option| can be ``NULL`` and the call is equivalent to\n `nghttp2_session_server_new()`.\n\n This function does not take ownership |option|. The application is\n responsible for freeing |option| if it finishes using the object.\n\n The library code does not refer to |option| after this function\n returns.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1244 pub fn nghttp2_session_server_new2(
1245 session_ptr: *mut *mut nghttp2_session,
1246 callbacks: *const nghttp2_session_callbacks,
1247 user_data: *mut ::std::os::raw::c_void,
1248 option: *const nghttp2_option,
1249 ) -> ::std::os::raw::c_int;
1250}
1251unsafe extern "C" {
1252 #[doc = " @function\n\n Like `nghttp2_session_client_new2()`, but with additional custom\n memory allocator specified in the |mem|.\n\n The |mem| can be ``NULL`` and the call is equivalent to\n `nghttp2_session_client_new2()`.\n\n This function does not take ownership |mem|. The application is\n responsible for freeing |mem|.\n\n The library code does not refer to |mem| pointer after this\n function returns, so the application can safely free it.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1253 pub fn nghttp2_session_client_new3(
1254 session_ptr: *mut *mut nghttp2_session,
1255 callbacks: *const nghttp2_session_callbacks,
1256 user_data: *mut ::std::os::raw::c_void,
1257 option: *const nghttp2_option,
1258 mem: *mut nghttp2_mem,
1259 ) -> ::std::os::raw::c_int;
1260}
1261unsafe extern "C" {
1262 #[doc = " @function\n\n Like `nghttp2_session_server_new2()`, but with additional custom\n memory allocator specified in the |mem|.\n\n The |mem| can be ``NULL`` and the call is equivalent to\n `nghttp2_session_server_new2()`.\n\n This function does not take ownership |mem|. The application is\n responsible for freeing |mem|.\n\n The library code does not refer to |mem| pointer after this\n function returns, so the application can safely free it.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1263 pub fn nghttp2_session_server_new3(
1264 session_ptr: *mut *mut nghttp2_session,
1265 callbacks: *const nghttp2_session_callbacks,
1266 user_data: *mut ::std::os::raw::c_void,
1267 option: *const nghttp2_option,
1268 mem: *mut nghttp2_mem,
1269 ) -> ::std::os::raw::c_int;
1270}
1271unsafe extern "C" {
1272 #[doc = " @function\n\n Frees any resources allocated for |session|. If |session| is\n ``NULL``, this function does nothing."]
1273 pub fn nghttp2_session_del(session: *mut nghttp2_session);
1274}
1275unsafe extern "C" {
1276 #[doc = " @function\n\n Sends pending frames to the remote peer.\n\n This function retrieves the highest prioritized frame from the\n outbound queue and sends it to the remote peer. It does this as\n many times as possible until the user callback\n :type:`nghttp2_send_callback2` returns\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`, the outbound queue\n becomes empty or flow control is triggered (remote window size\n becomes depleted or maximum number of concurrent streams is\n reached). This function calls several callback functions which are\n passed when initializing the |session|. Here is the simple time\n chart which tells when each callback is invoked:\n\n 1. Get the next frame to send from outbound queue.\n\n 2. Prepare transmission of the frame.\n\n 3. If the control frame cannot be sent because some preconditions\n are not met (e.g., request HEADERS cannot be sent after GOAWAY),\n :type:`nghttp2_on_frame_not_send_callback` is invoked. Abort\n the following steps.\n\n 4. If the frame is HEADERS, PUSH_PROMISE or DATA,\n :type:`nghttp2_select_padding_callback` is invoked.\n\n 5. If the frame is request HEADERS, the stream is opened here.\n\n 6. :type:`nghttp2_before_frame_send_callback` is invoked.\n\n 7. If :enum:`nghttp2_error.NGHTTP2_ERR_CANCEL` is returned from\n :type:`nghttp2_before_frame_send_callback`, the current frame\n transmission is canceled, and\n :type:`nghttp2_on_frame_not_send_callback` is invoked. Abort\n the following steps.\n\n 8. :type:`nghttp2_send_callback2` is invoked one or more times to\n send the frame.\n\n 9. :type:`nghttp2_on_frame_send_callback` is invoked.\n\n 10. If the transmission of the frame triggers closure of the\n stream, the stream is closed and\n :type:`nghttp2_on_stream_close_callback` is invoked.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`\n The callback function failed."]
1277 pub fn nghttp2_session_send(
1278 session: *mut nghttp2_session,
1279 ) -> ::std::os::raw::c_int;
1280}
1281unsafe extern "C" {
1282 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_session_mem_send2()` instead.\n\n Returns the serialized data to send.\n\n This function behaves like `nghttp2_session_send()` except that it\n does not use :type:`nghttp2_send_callback` to transmit data.\n Instead, it assigns the pointer to the serialized data to the\n |*data_ptr| and returns its length. The other callbacks are called\n in the same way as they are in `nghttp2_session_send()`.\n\n If no data is available to send, this function returns 0.\n\n This function may not return all serialized data in one invocation.\n To get all data, call this function repeatedly until it returns 0\n or one of negative error codes.\n\n The assigned |*data_ptr| is valid until the next call of\n `nghttp2_session_mem_send()` or `nghttp2_session_send()`.\n\n The caller must send all data before sending the next chunk of\n data.\n\n This function returns the length of the data pointed by the\n |*data_ptr| if it succeeds, or one of the following negative error\n codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n\n .. note::\n\n This function may produce very small byte string. If that is the\n case, and application disables Nagle algorithm (``TCP_NODELAY``),\n then writing this small chunk leads to very small packet, and it\n is very inefficient. An application should be responsible to\n buffer up small chunks of data as necessary to avoid this\n situation."]
1283 pub fn nghttp2_session_mem_send(
1284 session: *mut nghttp2_session,
1285 data_ptr: *mut *const u8,
1286 ) -> isize;
1287}
1288unsafe extern "C" {
1289 #[doc = " @function\n\n Returns the serialized data to send.\n\n This function behaves like `nghttp2_session_send()` except that it\n does not use :type:`nghttp2_send_callback2` to transmit data.\n Instead, it assigns the pointer to the serialized data to the\n |*data_ptr| and returns its length. The other callbacks are called\n in the same way as they are in `nghttp2_session_send()`.\n\n If no data is available to send, this function returns 0.\n\n This function may not return all serialized data in one invocation.\n To get all data, call this function repeatedly until it returns 0\n or one of negative error codes.\n\n The assigned |*data_ptr| is valid until the next call of\n `nghttp2_session_mem_send2()` or `nghttp2_session_send()`.\n\n The caller must send all data before sending the next chunk of\n data.\n\n This function returns the length of the data pointed by the\n |*data_ptr| if it succeeds, or one of the following negative error\n codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n\n .. note::\n\n This function may produce very small byte string. If that is the\n case, and application disables Nagle algorithm (``TCP_NODELAY``),\n then writing this small chunk leads to very small packet, and it\n is very inefficient. An application should be responsible to\n buffer up small chunks of data as necessary to avoid this\n situation."]
1290 pub fn nghttp2_session_mem_send2(
1291 session: *mut nghttp2_session,
1292 data_ptr: *mut *const u8,
1293 ) -> nghttp2_ssize;
1294}
1295unsafe extern "C" {
1296 #[doc = " @function\n\n Receives frames from the remote peer.\n\n This function receives as many frames as possible until the user\n callback :type:`nghttp2_recv_callback` returns\n :enum:`nghttp2_error.NGHTTP2_ERR_WOULDBLOCK`. This function calls\n several callback functions which are passed when initializing the\n |session|. Here is the simple time chart which tells when each\n callback is invoked:\n\n 1. :type:`nghttp2_recv_callback` is invoked one or more times to\n receive frame header.\n\n 2. When frame header is received,\n :type:`nghttp2_on_begin_frame_callback` is invoked.\n\n 3. If the frame is DATA frame:\n\n 1. :type:`nghttp2_recv_callback` is invoked to receive DATA\n payload. For each chunk of data,\n :type:`nghttp2_on_data_chunk_recv_callback` is invoked.\n\n 2. If one DATA frame is completely received,\n :type:`nghttp2_on_frame_recv_callback` is invoked. If the\n reception of the frame triggers the closure of the stream,\n :type:`nghttp2_on_stream_close_callback` is invoked.\n\n 4. If the frame is the control frame:\n\n 1. :type:`nghttp2_recv_callback` is invoked one or more times to\n receive whole frame.\n\n 2. If the received frame is valid, then following actions are\n taken. If the frame is either HEADERS or PUSH_PROMISE,\n :type:`nghttp2_on_begin_headers_callback` is invoked. Then\n :type:`nghttp2_on_header_callback` is invoked for each header\n name/value pair. For invalid header field,\n :type:`nghttp2_on_invalid_header_callback` is called. After\n all name/value pairs are emitted successfully,\n :type:`nghttp2_on_frame_recv_callback` is invoked. For other\n frames, :type:`nghttp2_on_frame_recv_callback` is invoked.\n If the reception of the frame triggers the closure of the\n stream, :type:`nghttp2_on_stream_close_callback` is invoked.\n\n 3. If the received frame is unpacked but is interpreted as\n invalid, :type:`nghttp2_on_invalid_frame_recv_callback` is\n invoked.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_EOF`\n The remote peer did shutdown on the connection.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`\n The callback function failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BAD_CLIENT_MAGIC`\n Invalid client magic was detected. This error only returns\n when |session| was configured as server and\n `nghttp2_option_set_no_recv_client_magic()` is not used with\n nonzero value.\n :enum:`nghttp2_error.NGHTTP2_ERR_FLOODED`\n Flooding was detected in this HTTP/2 session, and it must be\n closed. This is most likely caused by misbehaviour of peer."]
1297 pub fn nghttp2_session_recv(
1298 session: *mut nghttp2_session,
1299 ) -> ::std::os::raw::c_int;
1300}
1301unsafe extern "C" {
1302 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_session_mem_recv2()` instead.\n\n Processes data |in| as an input from the remote endpoint. The\n |inlen| indicates the number of bytes to receive in the |in|.\n\n This function behaves like `nghttp2_session_recv()` except that it\n does not use :type:`nghttp2_recv_callback` to receive data; the\n |in| is the only data for the invocation of this function. If all\n bytes are processed, this function returns. The other callbacks\n are called in the same way as they are in `nghttp2_session_recv()`.\n\n In the current implementation, this function always tries to\n processes |inlen| bytes of input data unless either an error occurs or\n :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` is returned from\n :type:`nghttp2_on_header_callback` or\n :type:`nghttp2_on_data_chunk_recv_callback`. If\n :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` is used, the return value\n includes the number of bytes which was used to produce the data or\n frame for the callback.\n\n This function returns the number of processed bytes, or one of the\n following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`\n The callback function failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BAD_CLIENT_MAGIC`\n Invalid client magic was detected. This error only returns\n when |session| was configured as server and\n `nghttp2_option_set_no_recv_client_magic()` is not used with\n nonzero value.\n :enum:`nghttp2_error.NGHTTP2_ERR_FLOODED`\n Flooding was detected in this HTTP/2 session, and it must be\n closed. This is most likely caused by misbehaviour of peer."]
1303 pub fn nghttp2_session_mem_recv(
1304 session: *mut nghttp2_session,
1305 in_: *const u8,
1306 inlen: usize,
1307 ) -> isize;
1308}
1309unsafe extern "C" {
1310 #[doc = " @function\n\n Processes data |in| as an input from the remote endpoint. The\n |inlen| indicates the number of bytes to receive in the |in|.\n\n This function behaves like `nghttp2_session_recv()` except that it\n does not use :type:`nghttp2_recv_callback` to receive data; the\n |in| is the only data for the invocation of this function. If all\n bytes are processed, this function returns. The other callbacks\n are called in the same way as they are in `nghttp2_session_recv()`.\n\n In the current implementation, this function always tries to\n processes |inlen| bytes of input data unless either an error occurs or\n :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` is returned from\n :type:`nghttp2_on_header_callback` or\n :type:`nghttp2_on_data_chunk_recv_callback`. If\n :enum:`nghttp2_error.NGHTTP2_ERR_PAUSE` is used, the return value\n includes the number of bytes which was used to produce the data or\n frame for the callback.\n\n This function returns the number of processed bytes, or one of the\n following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_CALLBACK_FAILURE`\n The callback function failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BAD_CLIENT_MAGIC`\n Invalid client magic was detected. This error only returns\n when |session| was configured as server and\n `nghttp2_option_set_no_recv_client_magic()` is not used with\n nonzero value.\n :enum:`nghttp2_error.NGHTTP2_ERR_FLOODED`\n Flooding was detected in this HTTP/2 session, and it must be\n closed. This is most likely caused by misbehaviour of peer."]
1311 pub fn nghttp2_session_mem_recv2(
1312 session: *mut nghttp2_session,
1313 in_: *const u8,
1314 inlen: usize,
1315 ) -> nghttp2_ssize;
1316}
1317unsafe extern "C" {
1318 #[doc = " @function\n\n Puts back previously deferred DATA frame in the stream |stream_id|\n to the outbound queue.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The stream does not exist; or no deferred data exist.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1319 pub fn nghttp2_session_resume_data(
1320 session: *mut nghttp2_session,
1321 stream_id: i32,
1322 ) -> ::std::os::raw::c_int;
1323}
1324unsafe extern "C" {
1325 #[doc = " @function\n\n Returns nonzero value if |session| wants to receive data from the\n remote peer.\n\n If both `nghttp2_session_want_read()` and\n `nghttp2_session_want_write()` return 0, the application should\n drop the connection."]
1326 pub fn nghttp2_session_want_read(
1327 session: *mut nghttp2_session,
1328 ) -> ::std::os::raw::c_int;
1329}
1330unsafe extern "C" {
1331 #[doc = " @function\n\n Returns nonzero value if |session| wants to send data to the remote\n peer.\n\n If both `nghttp2_session_want_read()` and\n `nghttp2_session_want_write()` return 0, the application should\n drop the connection."]
1332 pub fn nghttp2_session_want_write(
1333 session: *mut nghttp2_session,
1334 ) -> ::std::os::raw::c_int;
1335}
1336unsafe extern "C" {
1337 #[doc = " @function\n\n Returns stream_user_data for the stream |stream_id|. The\n stream_user_data is provided by `nghttp2_submit_request2()`,\n `nghttp2_submit_headers()` or\n `nghttp2_session_set_stream_user_data()`. Unless it is set using\n `nghttp2_session_set_stream_user_data()`, if the stream is\n initiated by the remote endpoint, stream_user_data is always\n ``NULL``. If the stream does not exist, this function returns\n ``NULL``."]
1338 pub fn nghttp2_session_get_stream_user_data(
1339 session: *mut nghttp2_session,
1340 stream_id: i32,
1341 ) -> *mut ::std::os::raw::c_void;
1342}
1343unsafe extern "C" {
1344 #[doc = " @function\n\n Sets the |stream_user_data| to the stream denoted by the\n |stream_id|. If a stream user data is already set to the stream,\n it is replaced with the |stream_user_data|. It is valid to specify\n ``NULL`` in the |stream_user_data|, which nullifies the associated\n data pointer.\n\n It is valid to set the |stream_user_data| to the stream reserved by\n PUSH_PROMISE frame.\n\n This function returns 0 if it succeeds, or one of following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The stream does not exist"]
1345 pub fn nghttp2_session_set_stream_user_data(
1346 session: *mut nghttp2_session,
1347 stream_id: i32,
1348 stream_user_data: *mut ::std::os::raw::c_void,
1349 ) -> ::std::os::raw::c_int;
1350}
1351unsafe extern "C" {
1352 #[doc = " @function\n\n Sets |user_data| to |session|, overwriting the existing user data\n specified in `nghttp2_session_client_new()`, or\n `nghttp2_session_server_new()`."]
1353 pub fn nghttp2_session_set_user_data(
1354 session: *mut nghttp2_session,
1355 user_data: *mut ::std::os::raw::c_void,
1356 );
1357}
1358unsafe extern "C" {
1359 #[doc = " @function\n\n Returns the number of frames in the outbound queue. This does not\n include the deferred DATA frames."]
1360 pub fn nghttp2_session_get_outbound_queue_size(
1361 session: *mut nghttp2_session,
1362 ) -> usize;
1363}
1364unsafe extern "C" {
1365 #[doc = " @function\n\n Returns the number of DATA payload in bytes received without\n WINDOW_UPDATE transmission for the stream |stream_id|. The local\n (receive) window size can be adjusted by\n `nghttp2_submit_window_update()`. This function takes into account\n that and returns effective data length. In particular, if the\n local window size is reduced by submitting negative\n window_size_increment with `nghttp2_submit_window_update()`, this\n function returns the number of bytes less than actually received.\n\n This function returns -1 if it fails."]
1366 pub fn nghttp2_session_get_stream_effective_recv_data_length(
1367 session: *mut nghttp2_session,
1368 stream_id: i32,
1369 ) -> i32;
1370}
1371unsafe extern "C" {
1372 #[doc = " @function\n\n Returns the local (receive) window size for the stream |stream_id|.\n The local window size can be adjusted by\n `nghttp2_submit_window_update()`. This function takes into account\n that and returns effective window size.\n\n This function does not take into account the amount of received\n data from the remote endpoint. Use\n `nghttp2_session_get_stream_local_window_size()` to know the amount\n of data the remote endpoint can send without receiving stream level\n WINDOW_UPDATE frame. Note that each stream is still subject to the\n connection level flow control.\n\n This function returns -1 if it fails."]
1373 pub fn nghttp2_session_get_stream_effective_local_window_size(
1374 session: *mut nghttp2_session,
1375 stream_id: i32,
1376 ) -> i32;
1377}
1378unsafe extern "C" {
1379 #[doc = " @function\n\n Returns the amount of flow-controlled payload (e.g., DATA) that the\n remote endpoint can send without receiving stream level\n WINDOW_UPDATE frame. It is also subject to the connection level\n flow control. So the actual amount of data to send is\n min(`nghttp2_session_get_stream_local_window_size()`,\n `nghttp2_session_get_local_window_size()`).\n\n This function returns -1 if it fails."]
1380 pub fn nghttp2_session_get_stream_local_window_size(
1381 session: *mut nghttp2_session,
1382 stream_id: i32,
1383 ) -> i32;
1384}
1385unsafe extern "C" {
1386 #[doc = " @function\n\n Returns the number of DATA payload in bytes received without\n WINDOW_UPDATE transmission for a connection. The local (receive)\n window size can be adjusted by `nghttp2_submit_window_update()`.\n This function takes into account that and returns effective data\n length. In particular, if the local window size is reduced by\n submitting negative window_size_increment with\n `nghttp2_submit_window_update()`, this function returns the number\n of bytes less than actually received.\n\n This function returns -1 if it fails."]
1387 pub fn nghttp2_session_get_effective_recv_data_length(
1388 session: *mut nghttp2_session,
1389 ) -> i32;
1390}
1391unsafe extern "C" {
1392 #[doc = " @function\n\n Returns the local (receive) window size for a connection. The\n local window size can be adjusted by\n `nghttp2_submit_window_update()`. This function takes into account\n that and returns effective window size.\n\n This function does not take into account the amount of received\n data from the remote endpoint. Use\n `nghttp2_session_get_local_window_size()` to know the amount of\n data the remote endpoint can send without receiving\n connection-level WINDOW_UPDATE frame. Note that each stream is\n still subject to the stream level flow control.\n\n This function returns -1 if it fails."]
1393 pub fn nghttp2_session_get_effective_local_window_size(
1394 session: *mut nghttp2_session,
1395 ) -> i32;
1396}
1397unsafe extern "C" {
1398 #[doc = " @function\n\n Returns the amount of flow-controlled payload (e.g., DATA) that the\n remote endpoint can send without receiving connection level\n WINDOW_UPDATE frame. Note that each stream is still subject to the\n stream level flow control (see\n `nghttp2_session_get_stream_local_window_size()`).\n\n This function returns -1 if it fails."]
1399 pub fn nghttp2_session_get_local_window_size(
1400 session: *mut nghttp2_session,
1401 ) -> i32;
1402}
1403unsafe extern "C" {
1404 #[doc = " @function\n\n Returns the remote window size for a given stream |stream_id|.\n\n This is the amount of flow-controlled payload (e.g., DATA) that the\n local endpoint can send without stream level WINDOW_UPDATE. There\n is also connection level flow control, so the effective size of\n payload that the local endpoint can actually send is\n min(`nghttp2_session_get_stream_remote_window_size()`,\n `nghttp2_session_get_remote_window_size()`).\n\n This function returns -1 if it fails."]
1405 pub fn nghttp2_session_get_stream_remote_window_size(
1406 session: *mut nghttp2_session,
1407 stream_id: i32,
1408 ) -> i32;
1409}
1410unsafe extern "C" {
1411 #[doc = " @function\n\n Returns the remote window size for a connection.\n\n This function always succeeds."]
1412 pub fn nghttp2_session_get_remote_window_size(
1413 session: *mut nghttp2_session,
1414 ) -> i32;
1415}
1416unsafe extern "C" {
1417 #[doc = " @function\n\n Returns 1 if local peer half closed the given stream |stream_id|.\n Returns 0 if it did not. Returns -1 if no such stream exists."]
1418 pub fn nghttp2_session_get_stream_local_close(
1419 session: *mut nghttp2_session,
1420 stream_id: i32,
1421 ) -> ::std::os::raw::c_int;
1422}
1423unsafe extern "C" {
1424 #[doc = " @function\n\n Returns 1 if remote peer half closed the given stream |stream_id|.\n Returns 0 if it did not. Returns -1 if no such stream exists."]
1425 pub fn nghttp2_session_get_stream_remote_close(
1426 session: *mut nghttp2_session,
1427 stream_id: i32,
1428 ) -> ::std::os::raw::c_int;
1429}
1430unsafe extern "C" {
1431 #[doc = " @function\n\n Returns the current dynamic table size of HPACK inflater, including\n the overhead 32 bytes per entry described in RFC 7541."]
1432 pub fn nghttp2_session_get_hd_inflate_dynamic_table_size(
1433 session: *mut nghttp2_session,
1434 ) -> usize;
1435}
1436unsafe extern "C" {
1437 #[doc = " @function\n\n Returns the current dynamic table size of HPACK deflater including\n the overhead 32 bytes per entry described in RFC 7541."]
1438 pub fn nghttp2_session_get_hd_deflate_dynamic_table_size(
1439 session: *mut nghttp2_session,
1440 ) -> usize;
1441}
1442unsafe extern "C" {
1443 #[doc = " @function\n\n Signals the session so that the connection should be terminated.\n\n The last stream ID is the minimum value between the stream ID of a\n stream for which :type:`nghttp2_on_frame_recv_callback` was called\n most recently and the last stream ID we have sent to the peer\n previously.\n\n The |error_code| is the error code of this GOAWAY frame. The\n pre-defined error code is one of :enum:`nghttp2_error_code`.\n\n After the transmission, both `nghttp2_session_want_read()` and\n `nghttp2_session_want_write()` return 0.\n\n This function should be called when the connection should be\n terminated after sending GOAWAY. If the remaining streams should\n be processed after GOAWAY, use `nghttp2_submit_goaway()` instead.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1444 pub fn nghttp2_session_terminate_session(
1445 session: *mut nghttp2_session,
1446 error_code: u32,
1447 ) -> ::std::os::raw::c_int;
1448}
1449unsafe extern "C" {
1450 #[doc = " @function\n\n Signals the session so that the connection should be terminated.\n\n This function behaves like `nghttp2_session_terminate_session()`,\n but the last stream ID can be specified by the application for fine\n grained control of stream. The HTTP/2 specification does not allow\n last_stream_id to be increased. So the actual value sent as\n last_stream_id is the minimum value between the given\n |last_stream_id| and the last_stream_id we have previously sent to\n the peer.\n\n The |last_stream_id| is peer's stream ID or 0. So if |session| is\n initialized as client, |last_stream_id| must be even or 0. If\n |session| is initialized as server, |last_stream_id| must be odd or\n 0.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |last_stream_id| is invalid."]
1451 pub fn nghttp2_session_terminate_session2(
1452 session: *mut nghttp2_session,
1453 last_stream_id: i32,
1454 error_code: u32,
1455 ) -> ::std::os::raw::c_int;
1456}
1457unsafe extern "C" {
1458 #[doc = " @function\n\n Signals to the client that the server started graceful shutdown\n procedure.\n\n This function is only usable for server. If this function is\n called with client side session, this function returns\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`.\n\n To gracefully shutdown HTTP/2 session, server should call this\n function to send GOAWAY with last_stream_id (1u << 31) - 1. And\n after some delay (e.g., 1 RTT), send another GOAWAY with the stream\n ID that the server has some processing using\n `nghttp2_submit_goaway()`. See also\n `nghttp2_session_get_last_proc_stream_id()`.\n\n Unlike `nghttp2_submit_goaway()`, this function just sends GOAWAY\n and does nothing more. This is a mere indication to the client\n that session shutdown is imminent. The application should call\n `nghttp2_submit_goaway()` with appropriate last_stream_id after\n this call.\n\n If one or more GOAWAY frame have been already sent by either\n `nghttp2_submit_goaway()` or `nghttp2_session_terminate_session()`,\n this function has no effect.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The |session| is initialized as client."]
1459 pub fn nghttp2_submit_shutdown_notice(
1460 session: *mut nghttp2_session,
1461 ) -> ::std::os::raw::c_int;
1462}
1463unsafe extern "C" {
1464 #[doc = " @function\n\n Returns the value of SETTINGS |id| notified by a remote endpoint.\n The |id| must be one of values defined in\n :enum:`nghttp2_settings_id`."]
1465 pub fn nghttp2_session_get_remote_settings(
1466 session: *mut nghttp2_session,
1467 id: nghttp2_settings_id,
1468 ) -> u32;
1469}
1470unsafe extern "C" {
1471 #[doc = " @function\n\n Returns the value of SETTINGS |id| of local endpoint acknowledged\n by the remote endpoint. The |id| must be one of the values defined\n in :enum:`nghttp2_settings_id`."]
1472 pub fn nghttp2_session_get_local_settings(
1473 session: *mut nghttp2_session,
1474 id: nghttp2_settings_id,
1475 ) -> u32;
1476}
1477unsafe extern "C" {
1478 #[doc = " @function\n\n Tells the |session| that next stream ID is |next_stream_id|. The\n |next_stream_id| must be equal or greater than the value returned\n by `nghttp2_session_get_next_stream_id()`.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |next_stream_id| is strictly less than the value\n `nghttp2_session_get_next_stream_id()` returns; or\n |next_stream_id| is invalid (e.g., even integer for client, or\n odd integer for server)."]
1479 pub fn nghttp2_session_set_next_stream_id(
1480 session: *mut nghttp2_session,
1481 next_stream_id: i32,
1482 ) -> ::std::os::raw::c_int;
1483}
1484unsafe extern "C" {
1485 #[doc = " @function\n\n Returns the next outgoing stream ID. Notice that return type is\n uint32_t. If we run out of stream ID for this session, this\n function returns 1 << 31."]
1486 pub fn nghttp2_session_get_next_stream_id(
1487 session: *mut nghttp2_session,
1488 ) -> u32;
1489}
1490unsafe extern "C" {
1491 #[doc = " @function\n\n Tells the |session| that |size| bytes for a stream denoted by\n |stream_id| were consumed by application and are ready to\n WINDOW_UPDATE. The consumed bytes are counted towards both\n connection and stream level WINDOW_UPDATE (see\n `nghttp2_session_consume_connection()` and\n `nghttp2_session_consume_stream()` to update consumption\n independently). This function is intended to be used without\n automatic window update (see\n `nghttp2_option_set_no_auto_window_update()`).\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n Automatic WINDOW_UPDATE is not disabled."]
1492 pub fn nghttp2_session_consume(
1493 session: *mut nghttp2_session,
1494 stream_id: i32,
1495 size: usize,
1496 ) -> ::std::os::raw::c_int;
1497}
1498unsafe extern "C" {
1499 #[doc = " @function\n\n Like `nghttp2_session_consume()`, but this only tells library that\n |size| bytes were consumed only for connection level. Note that\n HTTP/2 maintains connection and stream level flow control windows\n independently.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n Automatic WINDOW_UPDATE is not disabled."]
1500 pub fn nghttp2_session_consume_connection(
1501 session: *mut nghttp2_session,
1502 size: usize,
1503 ) -> ::std::os::raw::c_int;
1504}
1505unsafe extern "C" {
1506 #[doc = " @function\n\n Like `nghttp2_session_consume()`, but this only tells library that\n |size| bytes were consumed only for stream denoted by |stream_id|.\n Note that HTTP/2 maintains connection and stream level flow control\n windows independently.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n Automatic WINDOW_UPDATE is not disabled."]
1507 pub fn nghttp2_session_consume_stream(
1508 session: *mut nghttp2_session,
1509 stream_id: i32,
1510 size: usize,
1511 ) -> ::std::os::raw::c_int;
1512}
1513unsafe extern "C" {
1514 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function is noop. It always returns 0."]
1515 pub fn nghttp2_session_change_stream_priority(
1516 session: *mut nghttp2_session,
1517 stream_id: i32,
1518 pri_spec: *const nghttp2_priority_spec,
1519 ) -> ::std::os::raw::c_int;
1520}
1521unsafe extern "C" {
1522 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function is noop. It always returns 0."]
1523 pub fn nghttp2_session_create_idle_stream(
1524 session: *mut nghttp2_session,
1525 stream_id: i32,
1526 pri_spec: *const nghttp2_priority_spec,
1527 ) -> ::std::os::raw::c_int;
1528}
1529unsafe extern "C" {
1530 #[doc = " @function\n\n .. warning::\n\n This function is deprecated in favor of\n `nghttp2_session_upgrade2()`, because this function lacks the\n parameter to tell the library the request method used in the\n original HTTP request. This information is required for client\n to validate actual response body length against content-length\n header field (see `nghttp2_option_set_no_http_messaging()`). If\n HEAD is used in request, the length of response body must be 0\n regardless of value included in content-length header field.\n\n Performs post-process of HTTP Upgrade request. This function can\n be called from both client and server, but the behavior is very\n different in each other.\n\n If called from client side, the |settings_payload| must be the\n value sent in ``HTTP2-Settings`` header field and must be decoded\n by base64url decoder. The |settings_payloadlen| is the length of\n |settings_payload|. The |settings_payload| is unpacked and its\n setting values will be submitted using `nghttp2_submit_settings()`.\n This means that the client application code does not need to submit\n SETTINGS by itself. The stream with stream ID=1 is opened and the\n |stream_user_data| is used for its stream_user_data. The opened\n stream becomes half-closed (local) state.\n\n If called from server side, the |settings_payload| must be the\n value received in ``HTTP2-Settings`` header field and must be\n decoded by base64url decoder. The |settings_payloadlen| is the\n length of |settings_payload|. It is treated as if the SETTINGS\n frame with that payload is received. Thus, callback functions for\n the reception of SETTINGS frame will be invoked. The stream with\n stream ID=1 is opened. The |stream_user_data| is ignored. The\n opened stream becomes half-closed (remote).\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |settings_payload| is badly formed.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The stream ID 1 is already used or closed; or is not available."]
1531 pub fn nghttp2_session_upgrade(
1532 session: *mut nghttp2_session,
1533 settings_payload: *const u8,
1534 settings_payloadlen: usize,
1535 stream_user_data: *mut ::std::os::raw::c_void,
1536 ) -> ::std::os::raw::c_int;
1537}
1538unsafe extern "C" {
1539 #[doc = " @function\n\n Performs post-process of HTTP Upgrade request. This function can\n be called from both client and server, but the behavior is very\n different in each other.\n\n If called from client side, the |settings_payload| must be the\n value sent in ``HTTP2-Settings`` header field and must be decoded\n by base64url decoder. The |settings_payloadlen| is the length of\n |settings_payload|. The |settings_payload| is unpacked and its\n setting values will be submitted using `nghttp2_submit_settings()`.\n This means that the client application code does not need to submit\n SETTINGS by itself. The stream with stream ID=1 is opened and the\n |stream_user_data| is used for its stream_user_data. The opened\n stream becomes half-closed (local) state.\n\n If called from server side, the |settings_payload| must be the\n value received in ``HTTP2-Settings`` header field and must be\n decoded by base64url decoder. The |settings_payloadlen| is the\n length of |settings_payload|. It is treated as if the SETTINGS\n frame with that payload is received. Thus, callback functions for\n the reception of SETTINGS frame will be invoked. The stream with\n stream ID=1 is opened. The |stream_user_data| is ignored. The\n opened stream becomes half-closed (remote).\n\n If the request method is HEAD, pass nonzero value to\n |head_request|. Otherwise, pass 0.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |settings_payload| is badly formed.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The stream ID 1 is already used or closed; or is not available."]
1540 pub fn nghttp2_session_upgrade2(
1541 session: *mut nghttp2_session,
1542 settings_payload: *const u8,
1543 settings_payloadlen: usize,
1544 head_request: ::std::os::raw::c_int,
1545 stream_user_data: *mut ::std::os::raw::c_void,
1546 ) -> ::std::os::raw::c_int;
1547}
1548unsafe extern "C" {
1549 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_pack_settings_payload2()` instead.\n\n Serializes the SETTINGS values |iv| in the |buf|. The size of the\n |buf| is specified by |buflen|. The number of entries in the |iv|\n array is given by |niv|. The required space in |buf| for the |niv|\n entries is ``6*niv`` bytes and if the given buffer is too small, an\n error is returned. This function is used mainly for creating a\n SETTINGS payload to be sent with the ``HTTP2-Settings`` header\n field in an HTTP Upgrade request. The data written in |buf| is NOT\n base64url encoded and the application is responsible for encoding.\n\n This function returns the number of bytes written in |buf|, or one\n of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |iv| contains duplicate settings ID or invalid value.\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
1550 pub fn nghttp2_pack_settings_payload(
1551 buf: *mut u8,
1552 buflen: usize,
1553 iv: *const nghttp2_settings_entry,
1554 niv: usize,
1555 ) -> isize;
1556}
1557unsafe extern "C" {
1558 #[doc = " @function\n\n Serializes the SETTINGS values |iv| in the |buf|. The size of the\n |buf| is specified by |buflen|. The number of entries in the |iv|\n array is given by |niv|. The required space in |buf| for the |niv|\n entries is ``6*niv`` bytes and if the given buffer is too small, an\n error is returned. This function is used mainly for creating a\n SETTINGS payload to be sent with the ``HTTP2-Settings`` header\n field in an HTTP Upgrade request. The data written in |buf| is NOT\n base64url encoded and the application is responsible for encoding.\n\n This function returns the number of bytes written in |buf|, or one\n of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |iv| contains duplicate settings ID or invalid value.\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
1559 pub fn nghttp2_pack_settings_payload2(
1560 buf: *mut u8,
1561 buflen: usize,
1562 iv: *const nghttp2_settings_entry,
1563 niv: usize,
1564 ) -> nghttp2_ssize;
1565}
1566unsafe extern "C" {
1567 #[doc = " @function\n\n Returns string describing the |lib_error_code|. The\n |lib_error_code| must be one of the :enum:`nghttp2_error`."]
1568 pub fn nghttp2_strerror(
1569 lib_error_code: ::std::os::raw::c_int,
1570 ) -> *const ::std::os::raw::c_char;
1571}
1572unsafe extern "C" {
1573 #[doc = " @function\n\n Returns string representation of HTTP/2 error code |error_code|\n (e.g., ``PROTOCOL_ERROR`` is returned if ``error_code ==\n NGHTTP2_PROTOCOL_ERROR``). If string representation is unknown for\n given |error_code|, this function returns string ``unknown``."]
1574 pub fn nghttp2_http2_strerror(
1575 error_code: u32,
1576 ) -> *const ::std::os::raw::c_char;
1577}
1578unsafe extern "C" {
1579 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n Initializes |pri_spec| with the |stream_id| of the stream to depend\n on with |weight| and its exclusive flag. If |exclusive| is\n nonzero, exclusive flag is set.\n\n The |weight| must be in [:macro:`NGHTTP2_MIN_WEIGHT`,\n :macro:`NGHTTP2_MAX_WEIGHT`], inclusive."]
1580 pub fn nghttp2_priority_spec_init(
1581 pri_spec: *mut nghttp2_priority_spec,
1582 stream_id: i32,
1583 weight: i32,
1584 exclusive: ::std::os::raw::c_int,
1585 );
1586}
1587unsafe extern "C" {
1588 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n Initializes |pri_spec| with the default values. The default values\n are: stream_id = 0, weight = :macro:`NGHTTP2_DEFAULT_WEIGHT` and\n exclusive = 0."]
1589 pub fn nghttp2_priority_spec_default_init(
1590 pri_spec: *mut nghttp2_priority_spec,
1591 );
1592}
1593unsafe extern "C" {
1594 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n Returns nonzero if the |pri_spec| is filled with default values."]
1595 pub fn nghttp2_priority_spec_check_default(
1596 pri_spec: *const nghttp2_priority_spec,
1597 ) -> ::std::os::raw::c_int;
1598}
1599unsafe extern "C" {
1600 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_submit_request2()` instead.\n\n Submits HEADERS frame and optionally one or more DATA frames.\n\n The |pri_spec| is ignored.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n HTTP/2 specification has requirement about header fields in the\n request HEADERS. See the specification for more details.\n\n If |data_prd| is not ``NULL``, it provides data which will be sent\n in subsequent DATA frames. In this case, a method that allows\n request message bodies\n (https://tools.ietf.org/html/rfc7231#section-4) must be specified\n with ``:method`` key in |nva| (e.g. ``POST``). This function does\n not take ownership of the |data_prd|. The function copies the\n members of the |data_prd|. If |data_prd| is ``NULL``, HEADERS have\n END_STREAM set. The |stream_user_data| is data associated to the\n stream opened by this request and can be an arbitrary pointer,\n which can be retrieved later by\n `nghttp2_session_get_stream_user_data()`.\n\n This function returns assigned stream ID if it succeeds, or one of\n the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`\n No stream ID is available because maximum stream ID was\n reached.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The |session| is server session.\n\n .. warning::\n\n This function returns assigned stream ID if it succeeds. But\n that stream is not created yet. The application must not submit\n frame to that stream ID before\n :type:`nghttp2_before_frame_send_callback` is called for this\n frame. This means `nghttp2_session_get_stream_user_data()` does\n not work before the callback. But\n `nghttp2_session_set_stream_user_data()` handles this situation\n specially, and it can set data to a stream during this period.\n"]
1601 pub fn nghttp2_submit_request(
1602 session: *mut nghttp2_session,
1603 pri_spec: *const nghttp2_priority_spec,
1604 nva: *const nghttp2_nv,
1605 nvlen: usize,
1606 data_prd: *const nghttp2_data_provider,
1607 stream_user_data: *mut ::std::os::raw::c_void,
1608 ) -> i32;
1609}
1610unsafe extern "C" {
1611 #[doc = " @function\n\n Submits HEADERS frame and optionally one or more DATA frames.\n\n The |pri_spec| is ignored.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n HTTP/2 specification has requirement about header fields in the\n request HEADERS. See the specification for more details.\n\n If |data_prd| is not ``NULL``, it provides data which will be sent\n in subsequent DATA frames. In this case, a method that allows\n request message bodies\n (https://tools.ietf.org/html/rfc7231#section-4) must be specified\n with ``:method`` key in |nva| (e.g. ``POST``). This function does\n not take ownership of the |data_prd|. The function copies the\n members of the |data_prd|. If |data_prd| is ``NULL``, HEADERS have\n END_STREAM set. The |stream_user_data| is data associated to the\n stream opened by this request and can be an arbitrary pointer,\n which can be retrieved later by\n `nghttp2_session_get_stream_user_data()`.\n\n This function returns assigned stream ID if it succeeds, or one of\n the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`\n No stream ID is available because maximum stream ID was\n reached.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The |session| is server session.\n\n .. warning::\n\n This function returns assigned stream ID if it succeeds. But\n that stream is not created yet. The application must not submit\n frame to that stream ID before\n :type:`nghttp2_before_frame_send_callback` is called for this\n frame. This means `nghttp2_session_get_stream_user_data()` does\n not work before the callback. But\n `nghttp2_session_set_stream_user_data()` handles this situation\n specially, and it can set data to a stream during this period.\n"]
1612 pub fn nghttp2_submit_request2(
1613 session: *mut nghttp2_session,
1614 pri_spec: *const nghttp2_priority_spec,
1615 nva: *const nghttp2_nv,
1616 nvlen: usize,
1617 data_prd: *const nghttp2_data_provider2,
1618 stream_user_data: *mut ::std::os::raw::c_void,
1619 ) -> i32;
1620}
1621unsafe extern "C" {
1622 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_submit_response2()` instead.\n\n Submits response HEADERS frame and optionally one or more DATA\n frames against the stream |stream_id|.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n HTTP/2 specification has requirement about header fields in the\n response HEADERS. See the specification for more details.\n\n If |data_prd| is not ``NULL``, it provides data which will be sent\n in subsequent DATA frames. This function does not take ownership\n of the |data_prd|. The function copies the members of the\n |data_prd|. If |data_prd| is ``NULL``, HEADERS will have\n END_STREAM flag set.\n\n This method can be used as normal HTTP response and push response.\n When pushing a resource using this function, the |session| must be\n configured using `nghttp2_session_server_new()` or its variants and\n the target stream denoted by the |stream_id| must be reserved using\n `nghttp2_submit_push_promise()`.\n\n To send non-final response headers (e.g., HTTP status 101), don't\n use this function because this function half-closes the outbound\n stream. Instead, use `nghttp2_submit_headers()` for this purpose.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST`\n DATA or HEADERS has been already submitted and not fully\n processed yet. Normally, this does not happen, but when\n application wrongly calls `nghttp2_submit_response()` twice,\n this may happen.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The |session| is client session.\n\n .. warning::\n\n Calling this function twice for the same stream ID may lead to\n program crash. It is generally considered to a programming error\n to commit response twice."]
1623 pub fn nghttp2_submit_response(
1624 session: *mut nghttp2_session,
1625 stream_id: i32,
1626 nva: *const nghttp2_nv,
1627 nvlen: usize,
1628 data_prd: *const nghttp2_data_provider,
1629 ) -> ::std::os::raw::c_int;
1630}
1631unsafe extern "C" {
1632 #[doc = " @function\n\n Submits response HEADERS frame and optionally one or more DATA\n frames against the stream |stream_id|.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n HTTP/2 specification has requirement about header fields in the\n response HEADERS. See the specification for more details.\n\n If |data_prd| is not ``NULL``, it provides data which will be sent\n in subsequent DATA frames. This function does not take ownership\n of the |data_prd|. The function copies the members of the\n |data_prd|. If |data_prd| is ``NULL``, HEADERS will have\n END_STREAM flag set.\n\n This method can be used as normal HTTP response and push response.\n When pushing a resource using this function, the |session| must be\n configured using `nghttp2_session_server_new()` or its variants and\n the target stream denoted by the |stream_id| must be reserved using\n `nghttp2_submit_push_promise()`.\n\n To send non-final response headers (e.g., HTTP status 101), don't\n use this function because this function half-closes the outbound\n stream. Instead, use `nghttp2_submit_headers()` for this purpose.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST`\n DATA or HEADERS has been already submitted and not fully\n processed yet. Normally, this does not happen, but when\n application wrongly calls `nghttp2_submit_response2()` twice,\n this may happen.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The |session| is client session.\n\n .. warning::\n\n Calling this function twice for the same stream ID may lead to\n program crash. It is generally considered to a programming error\n to commit response twice."]
1633 pub fn nghttp2_submit_response2(
1634 session: *mut nghttp2_session,
1635 stream_id: i32,
1636 nva: *const nghttp2_nv,
1637 nvlen: usize,
1638 data_prd: *const nghttp2_data_provider2,
1639 ) -> ::std::os::raw::c_int;
1640}
1641unsafe extern "C" {
1642 #[doc = " @function\n\n Submits trailer fields HEADERS against the stream |stream_id|.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application must not include pseudo-header\n fields (headers whose names starts with \":\") in |nva|.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n For server, trailer fields must follow response HEADERS or response\n DATA without END_STREAM flat set. The library does not enforce\n this requirement, and applications should do this for themselves.\n If `nghttp2_submit_trailer()` is called before any response HEADERS\n submission (usually by `nghttp2_submit_response2()`), the content\n of |nva| will be sent as response headers, which will result in\n error.\n\n This function has the same effect with `nghttp2_submit_headers()`,\n with flags = :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM` and both\n pri_spec and stream_user_data to NULL.\n\n To submit trailer fields after `nghttp2_submit_response2()` is\n called, the application has to specify\n :type:`nghttp2_data_provider2` to `nghttp2_submit_response2()`.\n Inside of :type:`nghttp2_data_source_read_callback2`, when setting\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_EOF`, also set\n :enum:`nghttp2_data_flag.NGHTTP2_DATA_FLAG_NO_END_STREAM`. After\n that, the application can send trailer fields using\n `nghttp2_submit_trailer()`. `nghttp2_submit_trailer()` can be used\n inside :type:`nghttp2_data_source_read_callback2`.\n\n This function returns 0 if it succeeds and |stream_id| is -1.\n Otherwise, this function returns 0 if it succeeds, or one of the\n following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0."]
1643 pub fn nghttp2_submit_trailer(
1644 session: *mut nghttp2_session,
1645 stream_id: i32,
1646 nva: *const nghttp2_nv,
1647 nvlen: usize,
1648 ) -> ::std::os::raw::c_int;
1649}
1650unsafe extern "C" {
1651 #[doc = " @function\n\n Submits HEADERS frame. The |flags| is bitwise OR of the\n following values:\n\n * :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM`\n\n If |flags| includes :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM`,\n this frame has END_STREAM flag set.\n\n The library handles the CONTINUATION frame internally and it\n correctly sets END_HEADERS to the last sequence of the PUSH_PROMISE\n or CONTINUATION frame.\n\n If the |stream_id| is -1, this frame is assumed as request (i.e.,\n request HEADERS frame which opens new stream). In this case, the\n assigned stream ID will be returned. Otherwise, specify stream ID\n in |stream_id|.\n\n The |pri_spec| is ignored.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n The |stream_user_data| is a pointer to an arbitrary data which is\n associated to the stream this frame will open. Therefore it is\n only used if this frame opens streams, in other words, it changes\n stream state from idle or reserved to open.\n\n This function is low-level in a sense that the application code can\n specify flags directly. For usual HTTP request,\n `nghttp2_submit_request2()` is useful. Likewise, for HTTP\n response, prefer `nghttp2_submit_response2()`.\n\n This function returns newly assigned stream ID if it succeeds and\n |stream_id| is -1. Otherwise, this function returns 0 if it\n succeeds, or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`\n No stream ID is available because maximum stream ID was\n reached.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST`\n DATA or HEADERS has been already submitted and not fully\n processed yet. This happens if stream denoted by |stream_id|\n is in reserved state.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n The |stream_id| is -1, and |session| is server session.\n\n .. warning::\n\n This function returns assigned stream ID if it succeeds and\n |stream_id| is -1. But that stream is not opened yet. The\n application must not submit frame to that stream ID before\n :type:`nghttp2_before_frame_send_callback` is called for this\n frame.\n"]
1652 pub fn nghttp2_submit_headers(
1653 session: *mut nghttp2_session,
1654 flags: u8,
1655 stream_id: i32,
1656 pri_spec: *const nghttp2_priority_spec,
1657 nva: *const nghttp2_nv,
1658 nvlen: usize,
1659 stream_user_data: *mut ::std::os::raw::c_void,
1660 ) -> i32;
1661}
1662unsafe extern "C" {
1663 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_submit_data2()` instead.\n\n Submits one or more DATA frames to the stream |stream_id|. The\n data to be sent are provided by |data_prd|. If |flags| contains\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM`, the last DATA frame\n has END_STREAM flag set.\n\n This function does not take ownership of the |data_prd|. The\n function copies the members of the |data_prd|.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST`\n DATA or HEADERS has been already submitted and not fully\n processed yet.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_CLOSED`\n The stream was already closed; or the |stream_id| is invalid.\n\n .. note::\n\n Currently, only one DATA or HEADERS is allowed for a stream at a\n time. Submitting these frames more than once before first DATA\n or HEADERS is finished results in\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST` error code. The\n earliest callback which tells that previous frame is done is\n :type:`nghttp2_on_frame_send_callback`. In side that callback,\n new data can be submitted using `nghttp2_submit_data()`. Of\n course, all data except for last one must not have\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM` flag set in |flags|.\n This sounds a bit complicated, and we recommend to use\n `nghttp2_submit_request()` and `nghttp2_submit_response()` to\n avoid this cascading issue. The experience shows that for HTTP\n use, these two functions are enough to implement both client and\n server."]
1664 pub fn nghttp2_submit_data(
1665 session: *mut nghttp2_session,
1666 flags: u8,
1667 stream_id: i32,
1668 data_prd: *const nghttp2_data_provider,
1669 ) -> ::std::os::raw::c_int;
1670}
1671unsafe extern "C" {
1672 #[doc = " @function\n\n Submits one or more DATA frames to the stream |stream_id|. The\n data to be sent are provided by |data_prd|. If |flags| contains\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM`, the last DATA frame\n has END_STREAM flag set.\n\n This function does not take ownership of the |data_prd|. The\n function copies the members of the |data_prd|.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST`\n DATA or HEADERS has been already submitted and not fully\n processed yet.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_CLOSED`\n The stream was already closed; or the |stream_id| is invalid.\n\n .. note::\n\n Currently, only one DATA or HEADERS is allowed for a stream at a\n time. Submitting these frames more than once before first DATA\n or HEADERS is finished results in\n :enum:`nghttp2_error.NGHTTP2_ERR_DATA_EXIST` error code. The\n earliest callback which tells that previous frame is done is\n :type:`nghttp2_on_frame_send_callback`. In side that callback,\n new data can be submitted using `nghttp2_submit_data2()`. Of\n course, all data except for last one must not have\n :enum:`nghttp2_flag.NGHTTP2_FLAG_END_STREAM` flag set in |flags|.\n This sounds a bit complicated, and we recommend to use\n `nghttp2_submit_request2()` and `nghttp2_submit_response2()` to\n avoid this cascading issue. The experience shows that for HTTP\n use, these two functions are enough to implement both client and\n server."]
1673 pub fn nghttp2_submit_data2(
1674 session: *mut nghttp2_session,
1675 flags: u8,
1676 stream_id: i32,
1677 data_prd: *const nghttp2_data_provider2,
1678 ) -> ::std::os::raw::c_int;
1679}
1680unsafe extern "C" {
1681 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function is noop. It always returns 0."]
1682 pub fn nghttp2_submit_priority(
1683 session: *mut nghttp2_session,
1684 flags: u8,
1685 stream_id: i32,
1686 pri_spec: *const nghttp2_priority_spec,
1687 ) -> ::std::os::raw::c_int;
1688}
1689#[doc = " @struct\n\n :type:`nghttp2_extpri` is :rfc:`9218` extensible priorities\n specification for a stream."]
1690#[repr(C)]
1691#[derive(Debug, Copy, Clone)]
1692pub struct nghttp2_extpri {
1693 #[doc = " :member:`urgency` is the urgency of a stream, it must be in\n [:macro:`NGHTTP2_EXTPRI_URGENCY_HIGH`,\n :macro:`NGHTTP2_EXTPRI_URGENCY_LOW`], inclusive, and 0 is the\n highest urgency."]
1694 pub urgency: u32,
1695 #[doc = " :member:`inc` indicates that a content can be processed\n incrementally or not. If inc is 0, it cannot be processed\n incrementally. If inc is 1, it can be processed incrementally.\n Other value is not permitted."]
1696 pub inc: ::std::os::raw::c_int,
1697}
1698unsafe extern "C" {
1699 #[doc = " @function\n\n Submits RST_STREAM frame to cancel/reject the stream |stream_id|\n with the error code |error_code|.\n\n The pre-defined error code is one of :enum:`nghttp2_error_code`.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0."]
1700 pub fn nghttp2_submit_rst_stream(
1701 session: *mut nghttp2_session,
1702 flags: u8,
1703 stream_id: i32,
1704 error_code: u32,
1705 ) -> ::std::os::raw::c_int;
1706}
1707unsafe extern "C" {
1708 #[doc = " @function\n\n Stores local settings and submits SETTINGS frame. The |iv| is the\n pointer to the array of :type:`nghttp2_settings_entry`. The |niv|\n indicates the number of :type:`nghttp2_settings_entry`.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n This function does not take ownership of the |iv|. This function\n copies all the elements in the |iv|.\n\n While updating individual stream's local window size, if the window\n size becomes strictly larger than NGHTTP2_MAX_WINDOW_SIZE,\n RST_STREAM is issued against such a stream.\n\n SETTINGS with :enum:`nghttp2_flag.NGHTTP2_FLAG_ACK` is\n automatically submitted by the library and application could not\n send it at its will.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |iv| contains invalid value (e.g., initial window size\n strictly greater than (1 << 31) - 1.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1709 pub fn nghttp2_submit_settings(
1710 session: *mut nghttp2_session,
1711 flags: u8,
1712 iv: *const nghttp2_settings_entry,
1713 niv: usize,
1714 ) -> ::std::os::raw::c_int;
1715}
1716unsafe extern "C" {
1717 #[doc = " @function\n\n Submits PUSH_PROMISE frame.\n\n The |flags| is currently ignored. The library handles the\n CONTINUATION frame internally and it correctly sets END_HEADERS to\n the last sequence of the PUSH_PROMISE or CONTINUATION frame.\n\n The |stream_id| must be client initiated stream ID.\n\n The |nva| is an array of name/value pair :type:`nghttp2_nv` with\n |nvlen| elements. The application is responsible to include\n required pseudo-header fields (header field whose name starts with\n \":\") in |nva| and must place pseudo-headers before regular header\n fields.\n\n This function creates copies of all name/value pairs in |nva|. It\n also lower-cases all names in |nva|. The order of elements in\n |nva| is preserved. For header fields with\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME` and\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_VALUE` are set,\n header field name and value are not copied respectively. With\n :enum:`nghttp2_nv_flag.NGHTTP2_NV_FLAG_NO_COPY_NAME`, application\n is responsible to pass header field name in lowercase. The\n application should maintain the references to them until\n :type:`nghttp2_on_frame_send_callback` or\n :type:`nghttp2_on_frame_not_send_callback` is called.\n\n The |promised_stream_user_data| is a pointer to an arbitrary data\n which is associated to the promised stream this frame will open and\n make it in reserved state. It is available using\n `nghttp2_session_get_stream_user_data()`. The application can\n access it in :type:`nghttp2_before_frame_send_callback` and\n :type:`nghttp2_on_frame_send_callback` of this frame.\n\n The client side is not allowed to use this function.\n\n To submit response headers and data, use\n `nghttp2_submit_response2()`.\n\n This function returns assigned promised stream ID if it succeeds,\n or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_PROTO`\n This function was invoked when |session| is initialized as\n client.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE`\n No stream ID is available because maximum stream ID was\n reached.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is 0; The |stream_id| does not designate stream\n that peer initiated.\n :enum:`nghttp2_error.NGHTTP2_ERR_STREAM_CLOSED`\n The stream was already closed; or the |stream_id| is invalid.\n\n .. warning::\n\n This function returns assigned promised stream ID if it succeeds.\n As of 1.16.0, stream object for pushed resource is created when\n this function succeeds. In that case, the application can submit\n push response for the promised frame.\n\n In 1.15.0 or prior versions, pushed stream is not opened yet when\n this function succeeds. The application must not submit frame to\n that stream ID before :type:`nghttp2_before_frame_send_callback`\n is called for this frame.\n"]
1718 pub fn nghttp2_submit_push_promise(
1719 session: *mut nghttp2_session,
1720 flags: u8,
1721 stream_id: i32,
1722 nva: *const nghttp2_nv,
1723 nvlen: usize,
1724 promised_stream_user_data: *mut ::std::os::raw::c_void,
1725 ) -> i32;
1726}
1727unsafe extern "C" {
1728 #[doc = " @function\n\n Submits PING frame. You don't have to send PING back when you\n received PING frame. The library automatically submits PING frame\n in this case.\n\n The |flags| is bitwise OR of 0 or more of the following value.\n\n * :enum:`nghttp2_flag.NGHTTP2_FLAG_ACK`\n\n Unless `nghttp2_option_set_no_auto_ping_ack()` is used, the |flags|\n should be :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n If the |opaque_data| is non ``NULL``, then it should point to the 8\n bytes array of memory to specify opaque data to send with PING\n frame. If the |opaque_data| is ``NULL``, zero-cleared 8 bytes will\n be sent as opaque data.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1729 pub fn nghttp2_submit_ping(
1730 session: *mut nghttp2_session,
1731 flags: u8,
1732 opaque_data: *const u8,
1733 ) -> ::std::os::raw::c_int;
1734}
1735unsafe extern "C" {
1736 #[doc = " @function\n\n Submits GOAWAY frame with the last stream ID |last_stream_id| and\n the error code |error_code|.\n\n The pre-defined error code is one of :enum:`nghttp2_error_code`.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n The |last_stream_id| is peer's stream ID or 0. So if |session| is\n initialized as client, |last_stream_id| must be even or 0. If\n |session| is initialized as server, |last_stream_id| must be odd or\n 0.\n\n The HTTP/2 specification says last_stream_id must not be increased\n from the value previously sent. So the actual value sent as\n last_stream_id is the minimum value between the given\n |last_stream_id| and the last_stream_id previously sent to the\n peer.\n\n If the |opaque_data| is not ``NULL`` and |opaque_data_len| is not\n zero, those data will be sent as additional debug data. The\n library makes a copy of the memory region pointed by |opaque_data|\n with the length |opaque_data_len|, so the caller does not need to\n keep this memory after the return of this function. If the\n |opaque_data_len| is 0, the |opaque_data| could be ``NULL``.\n\n After successful transmission of GOAWAY, following things happen.\n All incoming streams having strictly more than |last_stream_id| are\n closed. All incoming HEADERS which starts new stream are simply\n ignored. After all active streams are handled, both\n `nghttp2_session_want_read()` and `nghttp2_session_want_write()`\n return 0 and the application can close session.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |opaque_data_len| is too large; the |last_stream_id| is\n invalid."]
1737 pub fn nghttp2_submit_goaway(
1738 session: *mut nghttp2_session,
1739 flags: u8,
1740 last_stream_id: i32,
1741 error_code: u32,
1742 opaque_data: *const u8,
1743 opaque_data_len: usize,
1744 ) -> ::std::os::raw::c_int;
1745}
1746unsafe extern "C" {
1747 #[doc = " @function\n\n Returns the last stream ID of a stream for which\n :type:`nghttp2_on_frame_recv_callback` was invoked most recently.\n The returned value can be used as last_stream_id parameter for\n `nghttp2_submit_goaway()` and\n `nghttp2_session_terminate_session2()`.\n\n This function always succeeds."]
1748 pub fn nghttp2_session_get_last_proc_stream_id(
1749 session: *mut nghttp2_session,
1750 ) -> i32;
1751}
1752unsafe extern "C" {
1753 #[doc = " @function\n\n Returns nonzero if new request can be sent from local endpoint.\n\n This function return 0 if request is not allowed for this session.\n There are several reasons why request is not allowed. Some of the\n reasons are: session is server; stream ID has been spent; GOAWAY\n has been sent or received.\n\n The application can call `nghttp2_submit_request2()` without\n consulting this function. In that case,\n `nghttp2_submit_request2()` may return error. Or, request is\n failed to sent, and :type:`nghttp2_on_stream_close_callback` is\n called."]
1754 pub fn nghttp2_session_check_request_allowed(
1755 session: *mut nghttp2_session,
1756 ) -> ::std::os::raw::c_int;
1757}
1758unsafe extern "C" {
1759 #[doc = " @function\n\n Returns nonzero if |session| is initialized as server side session."]
1760 pub fn nghttp2_session_check_server_session(
1761 session: *mut nghttp2_session,
1762 ) -> ::std::os::raw::c_int;
1763}
1764unsafe extern "C" {
1765 #[doc = " @function\n\n Submits WINDOW_UPDATE frame.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n The |stream_id| is the stream ID to send this WINDOW_UPDATE. To\n send connection level WINDOW_UPDATE, specify 0 to |stream_id|.\n\n If the |window_size_increment| is positive, the WINDOW_UPDATE with\n that value as window_size_increment is queued. If the\n |window_size_increment| is larger than the received bytes from the\n remote endpoint, the local window size is increased by that\n difference. If the sole purpose is to increase the local window\n size, consider to use `nghttp2_session_set_local_window_size()`.\n\n If the |window_size_increment| is negative, the local window size\n is decreased by -|window_size_increment|. If automatic\n WINDOW_UPDATE is enabled\n (`nghttp2_option_set_no_auto_window_update()`), and the library\n decided that the WINDOW_UPDATE should be submitted, then\n WINDOW_UPDATE is queued with the current received bytes count. If\n the sole purpose is to decrease the local window size, consider to\n use `nghttp2_session_set_local_window_size()`.\n\n If the |window_size_increment| is 0, the function does nothing and\n returns 0.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_FLOW_CONTROL`\n The local window size overflow or gets negative.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1766 pub fn nghttp2_submit_window_update(
1767 session: *mut nghttp2_session,
1768 flags: u8,
1769 stream_id: i32,
1770 window_size_increment: i32,
1771 ) -> ::std::os::raw::c_int;
1772}
1773unsafe extern "C" {
1774 #[doc = " @function\n\n Set local window size (local endpoints's window size) to the given\n |window_size| for the given stream denoted by |stream_id|. To\n change connection level window size, specify 0 to |stream_id|. To\n increase window size, this function may submit WINDOW_UPDATE frame\n to transmission queue.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n This sounds similar to `nghttp2_submit_window_update()`, but there\n are 2 differences. The first difference is that this function\n takes the absolute value of window size to set, rather than the\n delta. To change the window size, this may be easier to use since\n the application just declares the intended window size, rather than\n calculating delta. The second difference is that\n `nghttp2_submit_window_update()` affects the received bytes count\n which has not acked yet. By the specification of\n `nghttp2_submit_window_update()`, to strictly increase the local\n window size, we have to submit delta including all received bytes\n count, which might not be desirable in some cases. On the other\n hand, this function does not affect the received bytes count. It\n just sets the local window size to the given value.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |stream_id| is negative.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1775 pub fn nghttp2_session_set_local_window_size(
1776 session: *mut nghttp2_session,
1777 flags: u8,
1778 stream_id: i32,
1779 window_size: i32,
1780 ) -> ::std::os::raw::c_int;
1781}
1782unsafe extern "C" {
1783 #[doc = " @function\n\n Submits extension frame.\n\n Application can pass arbitrary frame flags and stream ID in |flags|\n and |stream_id| respectively. The |payload| is opaque pointer, and\n it can be accessible though ``frame->ext.payload`` in\n :type:`nghttp2_pack_extension_callback2`. The library will not own\n passed |payload| pointer.\n\n The application must set :type:`nghttp2_pack_extension_callback2`\n using `nghttp2_session_callbacks_set_pack_extension_callback2()`.\n\n The application should retain the memory pointed by |payload| until\n the transmission of extension frame is done (which is indicated by\n :type:`nghttp2_on_frame_send_callback`), or transmission fails\n (which is indicated by :type:`nghttp2_on_frame_not_send_callback`).\n If application does not touch this memory region after packing it\n into a wire format, application can free it inside\n :type:`nghttp2_pack_extension_callback2`.\n\n The standard HTTP/2 frame cannot be sent with this function, so\n |type| must be strictly grater than 0x9. Otherwise, this function\n will fail with error code\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n If :type:`nghttp2_pack_extension_callback2` is not set.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n If |type| specifies standard HTTP/2 frame type. The frame\n types in the rage [0x0, 0x9], both inclusive, are standard\n HTTP/2 frame type, and cannot be sent using this function.\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory"]
1784 pub fn nghttp2_submit_extension(
1785 session: *mut nghttp2_session,
1786 type_: u8,
1787 flags: u8,
1788 stream_id: i32,
1789 payload: *mut ::std::os::raw::c_void,
1790 ) -> ::std::os::raw::c_int;
1791}
1792#[doc = " @struct\n\n The payload of ALTSVC frame. ALTSVC frame is a non-critical\n extension to HTTP/2. If this frame is received, and\n `nghttp2_option_set_user_recv_extension_type()` is not set, and\n `nghttp2_option_set_builtin_recv_extension_type()` is set for\n :enum:`nghttp2_frame_type.NGHTTP2_ALTSVC`,\n ``nghttp2_extension.payload`` will point to this struct.\n\n It has the following members:"]
1793#[repr(C)]
1794#[derive(Debug, Copy, Clone)]
1795pub struct nghttp2_ext_altsvc {
1796 #[doc = " The pointer to origin which this alternative service is\n associated with. This is not necessarily NULL-terminated."]
1797 pub origin: *mut u8,
1798 #[doc = " The length of the |origin|."]
1799 pub origin_len: usize,
1800 #[doc = " The pointer to Alt-Svc field value contained in ALTSVC frame.\n This is not necessarily NULL-terminated."]
1801 pub field_value: *mut u8,
1802 #[doc = " The length of the |field_value|."]
1803 pub field_value_len: usize,
1804}
1805unsafe extern "C" {
1806 #[doc = " @function\n\n Submits ALTSVC frame.\n\n ALTSVC frame is a non-critical extension to HTTP/2, and defined in\n `RFC 7383 <https://tools.ietf.org/html/rfc7838#section-4>`_.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n The |origin| points to the origin this alternative service is\n associated with. The |origin_len| is the length of the origin. If\n |stream_id| is 0, the origin must be specified. If |stream_id| is\n not zero, the origin must be empty (in other words, |origin_len|\n must be 0).\n\n The ALTSVC frame is only usable from server side. If this function\n is invoked with client side session, this function returns\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The function is called from client side session\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The sum of |origin_len| and |field_value_len| is larger than\n 16382; or |origin_len| is 0 while |stream_id| is 0; or\n |origin_len| is not 0 while |stream_id| is not 0."]
1807 pub fn nghttp2_submit_altsvc(
1808 session: *mut nghttp2_session,
1809 flags: u8,
1810 stream_id: i32,
1811 origin: *const u8,
1812 origin_len: usize,
1813 field_value: *const u8,
1814 field_value_len: usize,
1815 ) -> ::std::os::raw::c_int;
1816}
1817#[doc = " @struct\n\n The single entry of an origin."]
1818#[repr(C)]
1819#[derive(Debug, Copy, Clone)]
1820pub struct nghttp2_origin_entry {
1821 #[doc = " The pointer to origin. No validation is made against this field\n by the library. This is not necessarily NULL-terminated."]
1822 pub origin: *mut u8,
1823 #[doc = " The length of the |origin|."]
1824 pub origin_len: usize,
1825}
1826#[doc = " @struct\n\n The payload of ORIGIN frame. ORIGIN frame is a non-critical\n extension to HTTP/2 and defined by `RFC 8336\n <https://tools.ietf.org/html/rfc8336>`_.\n\n If this frame is received, and\n `nghttp2_option_set_user_recv_extension_type()` is not set, and\n `nghttp2_option_set_builtin_recv_extension_type()` is set for\n :enum:`nghttp2_frame_type.NGHTTP2_ORIGIN`,\n ``nghttp2_extension.payload`` will point to this struct.\n\n It has the following members:"]
1827#[repr(C)]
1828#[derive(Debug, Copy, Clone)]
1829pub struct nghttp2_ext_origin {
1830 #[doc = " The number of origins contained in |ov|."]
1831 pub nov: usize,
1832 #[doc = " The pointer to the array of origins contained in ORIGIN frame."]
1833 pub ov: *mut nghttp2_origin_entry,
1834}
1835unsafe extern "C" {
1836 #[doc = " @function\n\n Submits ORIGIN frame.\n\n ORIGIN frame is a non-critical extension to HTTP/2 and defined by\n `RFC 8336 <https://tools.ietf.org/html/rfc8336>`_.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n The |ov| points to the array of origins. The |nov| specifies the\n number of origins included in |ov|. This function creates copies\n of all elements in |ov|.\n\n The ORIGIN frame is only usable by a server. If this function is\n invoked with client side session, this function returns\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`.\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The function is called from client side session.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n There are too many origins, or an origin is too large to fit\n into a default frame payload."]
1837 pub fn nghttp2_submit_origin(
1838 session: *mut nghttp2_session,
1839 flags: u8,
1840 ov: *const nghttp2_origin_entry,
1841 nov: usize,
1842 ) -> ::std::os::raw::c_int;
1843}
1844#[doc = " @struct\n\n The payload of PRIORITY_UPDATE frame. PRIORITY_UPDATE frame is a\n non-critical extension to HTTP/2. If this frame is received, and\n `nghttp2_option_set_user_recv_extension_type()` is not set, and\n `nghttp2_option_set_builtin_recv_extension_type()` is set for\n :enum:`nghttp2_frame_type.NGHTTP2_PRIORITY_UPDATE`,\n ``nghttp2_extension.payload`` will point to this struct.\n\n It has the following members:"]
1845#[repr(C)]
1846#[derive(Debug, Copy, Clone)]
1847pub struct nghttp2_ext_priority_update {
1848 #[doc = " The stream ID of the stream whose priority is updated."]
1849 pub stream_id: i32,
1850 #[doc = " The pointer to Priority field value. It is not necessarily\n NULL-terminated."]
1851 pub field_value: *mut u8,
1852 #[doc = " The length of the :member:`field_value`."]
1853 pub field_value_len: usize,
1854}
1855unsafe extern "C" {
1856 #[doc = " @function\n\n Submits PRIORITY_UPDATE frame.\n\n PRIORITY_UPDATE frame is a non-critical extension to HTTP/2, and\n defined in :rfc:`9218#section-7.1`.\n\n The |flags| is currently ignored and should be\n :enum:`nghttp2_flag.NGHTTP2_FLAG_NONE`.\n\n The |stream_id| is the ID of stream which is prioritized. The\n |field_value| points to the Priority field value. The\n |field_value_len| is the length of the Priority field value.\n\n If this function is called by server,\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE` is returned.\n\n If\n :enum:`nghttp2_settings_id.NGHTTP2_SETTINGS_NO_RFC7540_PRIORITIES`\n of value of 0 is received by a remote endpoint (or it is omitted),\n this function does nothing and returns 0.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The function is called from server side session\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n The |field_value_len| is larger than 16380; or |stream_id| is\n 0."]
1857 pub fn nghttp2_submit_priority_update(
1858 session: *mut nghttp2_session,
1859 flags: u8,
1860 stream_id: i32,
1861 field_value: *const u8,
1862 field_value_len: usize,
1863 ) -> ::std::os::raw::c_int;
1864}
1865unsafe extern "C" {
1866 #[doc = " @function\n\n Changes the priority of the existing stream denoted by |stream_id|.\n The new priority is |extpri|. This function is meant to be used by\n server for :rfc:`9218` extensible prioritization scheme.\n\n If |session| is initialized as client, this function returns\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`. For client, use\n `nghttp2_submit_priority_update()` instead.\n\n If :member:`extpri->urgency <nghttp2_extpri.urgency>` is out of\n bound, it is set to :macro:`NGHTTP2_EXTPRI_URGENCY_LOW`.\n\n If |ignore_client_signal| is nonzero, server starts to ignore\n client priority signals for this stream.\n\n If\n :enum:`nghttp2_settings_id.NGHTTP2_SETTINGS_NO_RFC7540_PRIORITIES`\n of value of 1 is not submitted via `nghttp2_submit_settings()`,\n this function does nothing and returns 0.\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The |session| is initialized as client.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n |stream_id| is zero; or a stream denoted by |stream_id| is not\n found."]
1867 pub fn nghttp2_session_change_extpri_stream_priority(
1868 session: *mut nghttp2_session,
1869 stream_id: i32,
1870 extpri: *const nghttp2_extpri,
1871 ignore_client_signal: ::std::os::raw::c_int,
1872 ) -> ::std::os::raw::c_int;
1873}
1874unsafe extern "C" {
1875 #[doc = " @function\n\n Stores the stream priority of the existing stream denoted by\n |stream_id| in the object pointed by |extpri|. This function is\n meant to be used by server for :rfc:`9218` extensible\n prioritization scheme.\n\n If |session| is initialized as client, this function returns\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`.\n\n If\n :enum:`nghttp2_settings_id.NGHTTP2_SETTINGS_NO_RFC7540_PRIORITIES`\n of value of 1 is not submitted via `nghttp2_submit_settings()`,\n this function does nothing and returns 0.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The |session| is initialized as client.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n |stream_id| is zero; or a stream denoted by |stream_id| is not\n found."]
1876 pub fn nghttp2_session_get_extpri_stream_priority(
1877 session: *mut nghttp2_session,
1878 extpri: *mut nghttp2_extpri,
1879 stream_id: i32,
1880 ) -> ::std::os::raw::c_int;
1881}
1882unsafe extern "C" {
1883 #[doc = " @function\n\n Parses Priority header field value pointed by |value| of length\n |len|, and stores the result in the object pointed by |extpri|.\n Priority header field is defined in :rfc:`9218`.\n\n This function does not initialize the object pointed by |extpri|\n before storing the result. It only assigns the values that the\n parser correctly extracted to fields.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_ARGUMENT`\n Failed to parse the header field value."]
1884 pub fn nghttp2_extpri_parse_priority(
1885 extpri: *mut nghttp2_extpri,
1886 value: *const u8,
1887 len: usize,
1888 ) -> ::std::os::raw::c_int;
1889}
1890unsafe extern "C" {
1891 #[doc = " @function\n\n Compares ``lhs->name`` of length ``lhs->namelen`` bytes and\n ``rhs->name`` of length ``rhs->namelen`` bytes. Returns negative\n integer if ``lhs->name`` is found to be less than ``rhs->name``; or\n returns positive integer if ``lhs->name`` is found to be greater\n than ``rhs->name``; or returns 0 otherwise."]
1892 pub fn nghttp2_nv_compare_name(
1893 lhs: *const nghttp2_nv,
1894 rhs: *const nghttp2_nv,
1895 ) -> ::std::os::raw::c_int;
1896}
1897unsafe extern "C" {
1898 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_select_alpn` instead.\n\n A helper function for dealing with ALPN in server side. The |in|\n contains peer's protocol list in preferable order. The format of\n |in| is length-prefixed and not null-terminated. For example,\n ``h2`` and ``http/1.1`` stored in |in| like this::\n\n in[0] = 2\n in[1..2] = \"h2\"\n in[3] = 8\n in[4..11] = \"http/1.1\"\n inlen = 12\n\n The selection algorithm is as follows:\n\n 1. If peer's list contains HTTP/2 protocol the library supports,\n it is selected and returns 1. The following step is not taken.\n\n 2. If peer's list contains ``http/1.1``, this function selects\n ``http/1.1`` and returns 0. The following step is not taken.\n\n 3. This function selects nothing and returns -1 (So called\n non-overlap case). In this case, |out| and |outlen| are left\n untouched.\n\n Selecting ``h2`` means that ``h2`` is written into |*out| and its\n length (which is 2) is assigned to |*outlen|.\n\n For ALPN, refer to https://tools.ietf.org/html/rfc7301\n\n To use this method you should do something like::\n\n static int alpn_select_proto_cb(SSL* ssl,\n const unsigned char **out,\n unsigned char *outlen,\n const unsigned char *in,\n unsigned int inlen,\n void *arg)\n {\n int rv;\n rv = nghttp2_select_next_protocol((unsigned char**)out, outlen,\n in, inlen);\n if (rv == -1) {\n return SSL_TLSEXT_ERR_NOACK;\n }\n if (rv == 1) {\n ((MyType*)arg)->http2_selected = 1;\n }\n return SSL_TLSEXT_ERR_OK;\n }\n ...\n SSL_CTX_set_alpn_select_cb(ssl_ctx, alpn_select_proto_cb, my_obj);\n"]
1899 pub fn nghttp2_select_next_protocol(
1900 out: *mut *mut ::std::os::raw::c_uchar,
1901 outlen: *mut ::std::os::raw::c_uchar,
1902 in_: *const ::std::os::raw::c_uchar,
1903 inlen: ::std::os::raw::c_uint,
1904 ) -> ::std::os::raw::c_int;
1905}
1906unsafe extern "C" {
1907 #[doc = " @function\n\n A helper function for dealing with ALPN in server side. The |in|\n contains peer's protocol list in preferable order. The format of\n |in| is length-prefixed and not null-terminated. For example,\n ``h2`` and ``http/1.1`` stored in |in| like this::\n\n in[0] = 2\n in[1..2] = \"h2\"\n in[3] = 8\n in[4..11] = \"http/1.1\"\n inlen = 12\n\n The selection algorithm is as follows:\n\n 1. If peer's list contains HTTP/2 protocol the library supports,\n it is selected and returns 1. The following step is not taken.\n\n 2. If peer's list contains ``http/1.1``, this function selects\n ``http/1.1`` and returns 0. The following step is not taken.\n\n 3. This function selects nothing and returns -1 (So called\n non-overlap case). In this case, |out| and |outlen| are left\n untouched.\n\n Selecting ``h2`` means that ``h2`` is written into |*out| and its\n length (which is 2) is assigned to |*outlen|.\n\n For ALPN, refer to https://tools.ietf.org/html/rfc7301\n\n To use this method you should do something like::\n\n static int alpn_select_proto_cb(SSL* ssl,\n const unsigned char **out,\n unsigned char *outlen,\n const unsigned char *in,\n unsigned int inlen,\n void *arg)\n {\n int rv;\n rv = nghttp2_select_alpn(out, outlen, in, inlen);\n if (rv == -1) {\n return SSL_TLSEXT_ERR_NOACK;\n }\n if (rv == 1) {\n ((MyType*)arg)->http2_selected = 1;\n }\n return SSL_TLSEXT_ERR_OK;\n }\n ...\n SSL_CTX_set_alpn_select_cb(ssl_ctx, alpn_select_proto_cb, my_obj);\n"]
1908 pub fn nghttp2_select_alpn(
1909 out: *mut *const ::std::os::raw::c_uchar,
1910 outlen: *mut ::std::os::raw::c_uchar,
1911 in_: *const ::std::os::raw::c_uchar,
1912 inlen: ::std::os::raw::c_uint,
1913 ) -> ::std::os::raw::c_int;
1914}
1915unsafe extern "C" {
1916 #[doc = " @function\n\n Returns a pointer to a nghttp2_info struct with version information\n about the run-time library in use. The |least_version| argument\n can be set to a 24 bit numerical value for the least accepted\n version number and if the condition is not met, this function will\n return a ``NULL``. Pass in 0 to skip the version checking."]
1917 pub fn nghttp2_version(
1918 least_version: ::std::os::raw::c_int,
1919 ) -> *mut nghttp2_info;
1920}
1921unsafe extern "C" {
1922 #[doc = " @function\n\n Returns nonzero if the :type:`nghttp2_error` library error code\n |lib_error| is fatal."]
1923 pub fn nghttp2_is_fatal(
1924 lib_error_code: ::std::os::raw::c_int,
1925 ) -> ::std::os::raw::c_int;
1926}
1927unsafe extern "C" {
1928 #[doc = " @function\n\n Returns nonzero if HTTP header field name |name| of length |len| is\n valid according to http://tools.ietf.org/html/rfc7230#section-3.2\n\n Because this is a header field name in HTTP2, the upper cased alphabet\n is treated as error."]
1929 pub fn nghttp2_check_header_name(
1930 name: *const u8,
1931 len: usize,
1932 ) -> ::std::os::raw::c_int;
1933}
1934unsafe extern "C" {
1935 #[doc = " @function\n\n Returns nonzero if HTTP header field value |value| of length |len|\n is valid according to\n http://tools.ietf.org/html/rfc7230#section-3.2\n\n This function is considered obsolete, and application should\n consider to use `nghttp2_check_header_value_rfc9113()` instead."]
1936 pub fn nghttp2_check_header_value(
1937 value: *const u8,
1938 len: usize,
1939 ) -> ::std::os::raw::c_int;
1940}
1941unsafe extern "C" {
1942 #[doc = " @function\n\n Returns nonzero if HTTP header field value |value| of length |len|\n is valid according to\n http://tools.ietf.org/html/rfc7230#section-3.2, plus\n https://datatracker.ietf.org/doc/html/rfc9113#section-8.2.1"]
1943 pub fn nghttp2_check_header_value_rfc9113(
1944 value: *const u8,
1945 len: usize,
1946 ) -> ::std::os::raw::c_int;
1947}
1948unsafe extern "C" {
1949 #[doc = " @function\n\n Returns nonzero if the |value| which is supposed to be the value of\n the :method header field is valid according to\n https://datatracker.ietf.org/doc/html/rfc7231#section-4 and\n https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6"]
1950 pub fn nghttp2_check_method(
1951 value: *const u8,
1952 len: usize,
1953 ) -> ::std::os::raw::c_int;
1954}
1955unsafe extern "C" {
1956 #[doc = " @function\n\n Returns nonzero if the |value| which is supposed to be the value of\n the :path header field is valid according to\n https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.3\n\n |value| is valid if it merely consists of the allowed characters.\n In particular, it does not check whether |value| follows the syntax\n of path. The allowed characters are all characters valid by\n `nghttp2_check_header_value` minus SPC and HT."]
1957 pub fn nghttp2_check_path(
1958 value: *const u8,
1959 len: usize,
1960 ) -> ::std::os::raw::c_int;
1961}
1962unsafe extern "C" {
1963 #[doc = " @function\n\n Returns nonzero if the |value| which is supposed to be the value of the\n :authority or host header field is valid according to\n https://tools.ietf.org/html/rfc3986#section-3.2\n\n Note that :authority and host field values are not authority. They\n do not include userinfo in RFC 3986, see\n https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2, that\n is, it does not include '@'. This function treats '@' as a valid\n character.\n\n |value| is valid if it merely consists of the allowed characters.\n In particular, it does not check whether |value| follows the syntax\n of authority."]
1964 pub fn nghttp2_check_authority(
1965 value: *const u8,
1966 len: usize,
1967 ) -> ::std::os::raw::c_int;
1968}
1969#[repr(C)]
1970#[derive(Debug, Copy, Clone)]
1971pub struct nghttp2_hd_deflater {
1972 _unused: [u8; 0],
1973}
1974unsafe extern "C" {
1975 #[doc = " @function\n\n Initializes |*deflater_ptr| for deflating name/values pairs.\n\n The |max_deflate_dynamic_table_size| is the upper bound of header\n table size the deflater will use.\n\n If this function fails, |*deflater_ptr| is left untouched.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1976 pub fn nghttp2_hd_deflate_new(
1977 deflater_ptr: *mut *mut nghttp2_hd_deflater,
1978 max_deflate_dynamic_table_size: usize,
1979 ) -> ::std::os::raw::c_int;
1980}
1981unsafe extern "C" {
1982 #[doc = " @function\n\n Like `nghttp2_hd_deflate_new()`, but with additional custom memory\n allocator specified in the |mem|.\n\n The |mem| can be ``NULL`` and the call is equivalent to\n `nghttp2_hd_deflate_new()`.\n\n This function does not take ownership |mem|. The application is\n responsible for freeing |mem|.\n\n The library code does not refer to |mem| pointer after this\n function returns, so the application can safely free it."]
1983 pub fn nghttp2_hd_deflate_new2(
1984 deflater_ptr: *mut *mut nghttp2_hd_deflater,
1985 max_deflate_dynamic_table_size: usize,
1986 mem: *mut nghttp2_mem,
1987 ) -> ::std::os::raw::c_int;
1988}
1989unsafe extern "C" {
1990 #[doc = " @function\n\n Deallocates any resources allocated for |deflater|."]
1991 pub fn nghttp2_hd_deflate_del(deflater: *mut nghttp2_hd_deflater);
1992}
1993unsafe extern "C" {
1994 #[doc = " @function\n\n Changes header table size of the |deflater| to\n |settings_max_dynamic_table_size| bytes. This may trigger eviction\n in the dynamic table.\n\n The |settings_max_dynamic_table_size| should be the value received\n in SETTINGS_HEADER_TABLE_SIZE.\n\n The deflater never uses more memory than\n ``max_deflate_dynamic_table_size`` bytes specified in\n `nghttp2_hd_deflate_new()`. Therefore, if\n |settings_max_dynamic_table_size| >\n ``max_deflate_dynamic_table_size``, resulting maximum table size\n becomes ``max_deflate_dynamic_table_size``.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
1995 pub fn nghttp2_hd_deflate_change_table_size(
1996 deflater: *mut nghttp2_hd_deflater,
1997 settings_max_dynamic_table_size: usize,
1998 ) -> ::std::os::raw::c_int;
1999}
2000unsafe extern "C" {
2001 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_hd_deflate_hd2()` instead.\n\n Deflates the |nva|, which has the |nvlen| name/value pairs, into\n the |buf| of length |buflen|.\n\n If |buf| is not large enough to store the deflated header block,\n this function fails with\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`. The caller\n should use `nghttp2_hd_deflate_bound()` to know the upper bound of\n buffer size required to deflate given header name/value pairs.\n\n Once this function fails, subsequent call of this function always\n returns :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`.\n\n After this function returns, it is safe to delete the |nva|.\n\n This function returns the number of bytes written to |buf| if it\n succeeds, or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Deflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
2002 pub fn nghttp2_hd_deflate_hd(
2003 deflater: *mut nghttp2_hd_deflater,
2004 buf: *mut u8,
2005 buflen: usize,
2006 nva: *const nghttp2_nv,
2007 nvlen: usize,
2008 ) -> isize;
2009}
2010unsafe extern "C" {
2011 #[doc = " @function\n\n Deflates the |nva|, which has the |nvlen| name/value pairs, into\n the |buf| of length |buflen|.\n\n If |buf| is not large enough to store the deflated header block,\n this function fails with\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`. The caller\n should use `nghttp2_hd_deflate_bound()` to know the upper bound of\n buffer size required to deflate given header name/value pairs.\n\n Once this function fails, subsequent call of this function always\n returns :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`.\n\n After this function returns, it is safe to delete the |nva|.\n\n This function returns the number of bytes written to |buf| if it\n succeeds, or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Deflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
2012 pub fn nghttp2_hd_deflate_hd2(
2013 deflater: *mut nghttp2_hd_deflater,
2014 buf: *mut u8,
2015 buflen: usize,
2016 nva: *const nghttp2_nv,
2017 nvlen: usize,
2018 ) -> nghttp2_ssize;
2019}
2020unsafe extern "C" {
2021 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_hd_deflate_hd_vec2()` instead.\n\n Deflates the |nva|, which has the |nvlen| name/value pairs, into\n the |veclen| size of buf vector |vec|. The each size of buffer\n must be set in len field of :type:`nghttp2_vec`. If and only if\n one chunk is filled up completely, next chunk will be used. If\n |vec| is not large enough to store the deflated header block, this\n function fails with\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`. The caller\n should use `nghttp2_hd_deflate_bound()` to know the upper bound of\n buffer size required to deflate given header name/value pairs.\n\n Once this function fails, subsequent call of this function always\n returns :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`.\n\n After this function returns, it is safe to delete the |nva|.\n\n This function returns the number of bytes written to |vec| if it\n succeeds, or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Deflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
2022 pub fn nghttp2_hd_deflate_hd_vec(
2023 deflater: *mut nghttp2_hd_deflater,
2024 vec: *const nghttp2_vec,
2025 veclen: usize,
2026 nva: *const nghttp2_nv,
2027 nvlen: usize,
2028 ) -> isize;
2029}
2030unsafe extern "C" {
2031 #[doc = " @function\n\n Deflates the |nva|, which has the |nvlen| name/value pairs, into\n the |veclen| size of buf vector |vec|. The each size of buffer\n must be set in len field of :type:`nghttp2_vec`. If and only if\n one chunk is filled up completely, next chunk will be used. If\n |vec| is not large enough to store the deflated header block, this\n function fails with\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`. The caller\n should use `nghttp2_hd_deflate_bound()` to know the upper bound of\n buffer size required to deflate given header name/value pairs.\n\n Once this function fails, subsequent call of this function always\n returns :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`.\n\n After this function returns, it is safe to delete the |nva|.\n\n This function returns the number of bytes written to |vec| if it\n succeeds, or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Deflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_INSUFF_BUFSIZE`\n The provided |buflen| size is too small to hold the output."]
2032 pub fn nghttp2_hd_deflate_hd_vec2(
2033 deflater: *mut nghttp2_hd_deflater,
2034 vec: *const nghttp2_vec,
2035 veclen: usize,
2036 nva: *const nghttp2_nv,
2037 nvlen: usize,
2038 ) -> nghttp2_ssize;
2039}
2040unsafe extern "C" {
2041 #[doc = " @function\n\n Returns an upper bound on the compressed size after deflation of\n |nva| of length |nvlen|."]
2042 pub fn nghttp2_hd_deflate_bound(
2043 deflater: *mut nghttp2_hd_deflater,
2044 nva: *const nghttp2_nv,
2045 nvlen: usize,
2046 ) -> usize;
2047}
2048unsafe extern "C" {
2049 #[doc = " @function\n\n Returns the number of entries that header table of |deflater|\n contains. This is the sum of the number of static table and\n dynamic table, so the return value is at least 61."]
2050 pub fn nghttp2_hd_deflate_get_num_table_entries(
2051 deflater: *mut nghttp2_hd_deflater,
2052 ) -> usize;
2053}
2054unsafe extern "C" {
2055 #[doc = " @function\n\n Returns the table entry denoted by |idx| from header table of\n |deflater|. The |idx| is 1-based, and idx=1 returns first entry of\n static table. idx=62 returns first entry of dynamic table if it\n exists. Specifying idx=0 is error, and this function returns NULL.\n If |idx| is strictly greater than the number of entries the tables\n contain, this function returns NULL."]
2056 pub fn nghttp2_hd_deflate_get_table_entry(
2057 deflater: *mut nghttp2_hd_deflater,
2058 idx: usize,
2059 ) -> *const nghttp2_nv;
2060}
2061unsafe extern "C" {
2062 #[doc = " @function\n\n Returns the used dynamic table size, including the overhead 32\n bytes per entry described in RFC 7541."]
2063 pub fn nghttp2_hd_deflate_get_dynamic_table_size(
2064 deflater: *mut nghttp2_hd_deflater,
2065 ) -> usize;
2066}
2067unsafe extern "C" {
2068 #[doc = " @function\n\n Returns the maximum dynamic table size."]
2069 pub fn nghttp2_hd_deflate_get_max_dynamic_table_size(
2070 deflater: *mut nghttp2_hd_deflater,
2071 ) -> usize;
2072}
2073#[repr(C)]
2074#[derive(Debug, Copy, Clone)]
2075pub struct nghttp2_hd_inflater {
2076 _unused: [u8; 0],
2077}
2078unsafe extern "C" {
2079 #[doc = " @function\n\n Initializes |*inflater_ptr| for inflating name/values pairs.\n\n If this function fails, |*inflater_ptr| is left untouched.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory."]
2080 pub fn nghttp2_hd_inflate_new(
2081 inflater_ptr: *mut *mut nghttp2_hd_inflater,
2082 ) -> ::std::os::raw::c_int;
2083}
2084unsafe extern "C" {
2085 #[doc = " @function\n\n Like `nghttp2_hd_inflate_new()`, but with additional custom memory\n allocator specified in the |mem|.\n\n The |mem| can be ``NULL`` and the call is equivalent to\n `nghttp2_hd_inflate_new()`.\n\n This function does not take ownership |mem|. The application is\n responsible for freeing |mem|.\n\n The library code does not refer to |mem| pointer after this\n function returns, so the application can safely free it."]
2086 pub fn nghttp2_hd_inflate_new2(
2087 inflater_ptr: *mut *mut nghttp2_hd_inflater,
2088 mem: *mut nghttp2_mem,
2089 ) -> ::std::os::raw::c_int;
2090}
2091unsafe extern "C" {
2092 #[doc = " @function\n\n Deallocates any resources allocated for |inflater|."]
2093 pub fn nghttp2_hd_inflate_del(inflater: *mut nghttp2_hd_inflater);
2094}
2095unsafe extern "C" {
2096 #[doc = " @function\n\n Changes header table size in the |inflater|. This may trigger\n eviction in the dynamic table.\n\n The |settings_max_dynamic_table_size| should be the value\n transmitted in SETTINGS_HEADER_TABLE_SIZE.\n\n This function must not be called while header block is being\n inflated. In other words, this function must be called after\n initialization of |inflater|, but before calling\n `nghttp2_hd_inflate_hd3()`, or after\n `nghttp2_hd_inflate_end_headers()`. Otherwise,\n `NGHTTP2_ERR_INVALID_STATE` was returned.\n\n This function returns 0 if it succeeds, or one of the following\n negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_INVALID_STATE`\n The function is called while header block is being inflated.\n Probably, application missed to call\n `nghttp2_hd_inflate_end_headers()`."]
2097 pub fn nghttp2_hd_inflate_change_table_size(
2098 inflater: *mut nghttp2_hd_inflater,
2099 settings_max_dynamic_table_size: usize,
2100 ) -> ::std::os::raw::c_int;
2101}
2102#[doc = " No flag set."]
2103pub const NGHTTP2_HD_INFLATE_NONE: nghttp2_hd_inflate_flag = 0;
2104#[doc = " Indicates all headers were inflated."]
2105pub const NGHTTP2_HD_INFLATE_FINAL: nghttp2_hd_inflate_flag = 1;
2106#[doc = " Indicates a header was emitted."]
2107pub const NGHTTP2_HD_INFLATE_EMIT: nghttp2_hd_inflate_flag = 2;
2108#[doc = " @enum\n\n The flags for header inflation."]
2109pub type nghttp2_hd_inflate_flag = u32;
2110unsafe extern "C" {
2111 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_hd_inflate_hd2()` instead.\n\n Inflates name/value block stored in |in| with length |inlen|. This\n function performs decompression. For each successful emission of\n header name/value pair,\n :enum:`nghttp2_hd_inflate_flag.NGHTTP2_HD_INFLATE_EMIT` is set in\n |*inflate_flags| and name/value pair is assigned to the |nv_out|\n and the function returns. The caller must not free the members of\n |nv_out|.\n\n The |nv_out| may include pointers to the memory region in the |in|.\n The caller must retain the |in| while the |nv_out| is used.\n\n The application should call this function repeatedly until the\n ``(*inflate_flags) & NGHTTP2_HD_INFLATE_FINAL`` is nonzero and\n return value is non-negative. This means the all input values are\n processed successfully. Then the application must call\n `nghttp2_hd_inflate_end_headers()` to prepare for the next header\n block input.\n\n The caller can feed complete compressed header block. It also can\n feed it in several chunks. The caller must set |in_final| to\n nonzero if the given input is the last block of the compressed\n header.\n\n This function returns the number of bytes processed if it succeeds,\n or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Inflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BUFFER_ERROR`\n The header field name or value is too large.\n\n Example follows::\n\n int inflate_header_block(nghttp2_hd_inflater *hd_inflater,\n uint8_t *in, size_t inlen, int final)\n {\n ssize_t rv;\n\n for(;;) {\n nghttp2_nv nv;\n int inflate_flags = 0;\n\n rv = nghttp2_hd_inflate_hd(hd_inflater, &nv, &inflate_flags,\n in, inlen, final);\n\n if(rv < 0) {\n fprintf(stderr, \"inflate failed with error code %zd\", rv);\n return -1;\n }\n\n in += rv;\n inlen -= rv;\n\n if(inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {\n fwrite(nv.name, nv.namelen, 1, stderr);\n fprintf(stderr, \": \");\n fwrite(nv.value, nv.valuelen, 1, stderr);\n fprintf(stderr, \"\\n\");\n }\n if(inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {\n nghttp2_hd_inflate_end_headers(hd_inflater);\n break;\n }\n if((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 &&\n inlen == 0) {\n break;\n }\n }\n\n return 0;\n }\n"]
2112 pub fn nghttp2_hd_inflate_hd(
2113 inflater: *mut nghttp2_hd_inflater,
2114 nv_out: *mut nghttp2_nv,
2115 inflate_flags: *mut ::std::os::raw::c_int,
2116 in_: *mut u8,
2117 inlen: usize,
2118 in_final: ::std::os::raw::c_int,
2119 ) -> isize;
2120}
2121unsafe extern "C" {
2122 #[doc = " @function\n\n .. warning::\n\n Deprecated. Use `nghttp2_hd_inflate_hd3()` instead.\n\n Inflates name/value block stored in |in| with length |inlen|. This\n function performs decompression. For each successful emission of\n header name/value pair,\n :enum:`nghttp2_hd_inflate_flag.NGHTTP2_HD_INFLATE_EMIT` is set in\n |*inflate_flags| and name/value pair is assigned to the |nv_out|\n and the function returns. The caller must not free the members of\n |nv_out|.\n\n The |nv_out| may include pointers to the memory region in the |in|.\n The caller must retain the |in| while the |nv_out| is used.\n\n The application should call this function repeatedly until the\n ``(*inflate_flags) & NGHTTP2_HD_INFLATE_FINAL`` is nonzero and\n return value is non-negative. If that happens, all given input\n data (|inlen| bytes) are processed successfully. Then the\n application must call `nghttp2_hd_inflate_end_headers()` to prepare\n for the next header block input.\n\n In other words, if |in_final| is nonzero, and this function returns\n |inlen|, you can assert that\n :enum:`nghttp2_hd_inflate_final.NGHTTP2_HD_INFLATE_FINAL` is set in\n |*inflate_flags|.\n\n The caller can feed complete compressed header block. It also can\n feed it in several chunks. The caller must set |in_final| to\n nonzero if the given input is the last block of the compressed\n header.\n\n This function returns the number of bytes processed if it succeeds,\n or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Inflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BUFFER_ERROR`\n The header field name or value is too large.\n\n Example follows::\n\n int inflate_header_block(nghttp2_hd_inflater *hd_inflater,\n uint8_t *in, size_t inlen, int final)\n {\n ssize_t rv;\n\n for(;;) {\n nghttp2_nv nv;\n int inflate_flags = 0;\n\n rv = nghttp2_hd_inflate_hd2(hd_inflater, &nv, &inflate_flags,\n in, inlen, final);\n\n if(rv < 0) {\n fprintf(stderr, \"inflate failed with error code %zd\", rv);\n return -1;\n }\n\n in += rv;\n inlen -= rv;\n\n if(inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {\n fwrite(nv.name, nv.namelen, 1, stderr);\n fprintf(stderr, \": \");\n fwrite(nv.value, nv.valuelen, 1, stderr);\n fprintf(stderr, \"\\n\");\n }\n if(inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {\n nghttp2_hd_inflate_end_headers(hd_inflater);\n break;\n }\n if((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 &&\n inlen == 0) {\n break;\n }\n }\n\n return 0;\n }\n"]
2123 pub fn nghttp2_hd_inflate_hd2(
2124 inflater: *mut nghttp2_hd_inflater,
2125 nv_out: *mut nghttp2_nv,
2126 inflate_flags: *mut ::std::os::raw::c_int,
2127 in_: *const u8,
2128 inlen: usize,
2129 in_final: ::std::os::raw::c_int,
2130 ) -> isize;
2131}
2132unsafe extern "C" {
2133 #[doc = " @function\n\n Inflates name/value block stored in |in| with length |inlen|. This\n function performs decompression. For each successful emission of\n header name/value pair,\n :enum:`nghttp2_hd_inflate_flag.NGHTTP2_HD_INFLATE_EMIT` is set in\n |*inflate_flags| and name/value pair is assigned to the |nv_out|\n and the function returns. The caller must not free the members of\n |nv_out|.\n\n The |nv_out| may include pointers to the memory region in the |in|.\n The caller must retain the |in| while the |nv_out| is used.\n\n The application should call this function repeatedly until the\n ``(*inflate_flags) & NGHTTP2_HD_INFLATE_FINAL`` is nonzero and\n return value is non-negative. If that happens, all given input\n data (|inlen| bytes) are processed successfully. Then the\n application must call `nghttp2_hd_inflate_end_headers()` to prepare\n for the next header block input.\n\n In other words, if |in_final| is nonzero, and this function returns\n |inlen|, you can assert that\n :enum:`nghttp2_hd_inflate_final.NGHTTP2_HD_INFLATE_FINAL` is set in\n |*inflate_flags|.\n\n The caller can feed complete compressed header block. It also can\n feed it in several chunks. The caller must set |in_final| to\n nonzero if the given input is the last block of the compressed\n header.\n\n This function returns the number of bytes processed if it succeeds,\n or one of the following negative error codes:\n\n :enum:`nghttp2_error.NGHTTP2_ERR_NOMEM`\n Out of memory.\n :enum:`nghttp2_error.NGHTTP2_ERR_HEADER_COMP`\n Inflation process has failed.\n :enum:`nghttp2_error.NGHTTP2_ERR_BUFFER_ERROR`\n The header field name or value is too large.\n\n Example follows::\n\n int inflate_header_block(nghttp2_hd_inflater *hd_inflater,\n uint8_t *in, size_t inlen, int final)\n {\n nghttp2_ssize rv;\n\n for(;;) {\n nghttp2_nv nv;\n int inflate_flags = 0;\n\n rv = nghttp2_hd_inflate_hd3(hd_inflater, &nv, &inflate_flags,\n in, inlen, final);\n\n if(rv < 0) {\n fprintf(stderr, \"inflate failed with error code %td\", rv);\n return -1;\n }\n\n in += rv;\n inlen -= rv;\n\n if(inflate_flags & NGHTTP2_HD_INFLATE_EMIT) {\n fwrite(nv.name, nv.namelen, 1, stderr);\n fprintf(stderr, \": \");\n fwrite(nv.value, nv.valuelen, 1, stderr);\n fprintf(stderr, \"\\n\");\n }\n if(inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {\n nghttp2_hd_inflate_end_headers(hd_inflater);\n break;\n }\n if((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 &&\n inlen == 0) {\n break;\n }\n }\n\n return 0;\n }\n"]
2134 pub fn nghttp2_hd_inflate_hd3(
2135 inflater: *mut nghttp2_hd_inflater,
2136 nv_out: *mut nghttp2_nv,
2137 inflate_flags: *mut ::std::os::raw::c_int,
2138 in_: *const u8,
2139 inlen: usize,
2140 in_final: ::std::os::raw::c_int,
2141 ) -> nghttp2_ssize;
2142}
2143unsafe extern "C" {
2144 #[doc = " @function\n\n Signals the end of decompression for one header block.\n\n This function returns 0 if it succeeds. Currently this function\n always succeeds."]
2145 pub fn nghttp2_hd_inflate_end_headers(
2146 inflater: *mut nghttp2_hd_inflater,
2147 ) -> ::std::os::raw::c_int;
2148}
2149unsafe extern "C" {
2150 #[doc = " @function\n\n Returns the number of entries that header table of |inflater|\n contains. This is the sum of the number of static table and\n dynamic table, so the return value is at least 61."]
2151 pub fn nghttp2_hd_inflate_get_num_table_entries(
2152 inflater: *mut nghttp2_hd_inflater,
2153 ) -> usize;
2154}
2155unsafe extern "C" {
2156 #[doc = " @function\n\n Returns the table entry denoted by |idx| from header table of\n |inflater|. The |idx| is 1-based, and idx=1 returns first entry of\n static table. idx=62 returns first entry of dynamic table if it\n exists. Specifying idx=0 is error, and this function returns NULL.\n If |idx| is strictly greater than the number of entries the tables\n contain, this function returns NULL."]
2157 pub fn nghttp2_hd_inflate_get_table_entry(
2158 inflater: *mut nghttp2_hd_inflater,
2159 idx: usize,
2160 ) -> *const nghttp2_nv;
2161}
2162unsafe extern "C" {
2163 #[doc = " @function\n\n Returns the used dynamic table size, including the overhead 32\n bytes per entry described in RFC 7541."]
2164 pub fn nghttp2_hd_inflate_get_dynamic_table_size(
2165 inflater: *mut nghttp2_hd_inflater,
2166 ) -> usize;
2167}
2168unsafe extern "C" {
2169 #[doc = " @function\n\n Returns the maximum dynamic table size."]
2170 pub fn nghttp2_hd_inflate_get_max_dynamic_table_size(
2171 inflater: *mut nghttp2_hd_inflater,
2172 ) -> usize;
2173}
2174#[repr(C)]
2175#[derive(Debug, Copy, Clone)]
2176pub struct nghttp2_stream {
2177 _unused: [u8; 0],
2178}
2179unsafe extern "C" {
2180 #[doc = " @function\n\n Returns pointer to :type:`nghttp2_stream` object denoted by\n |stream_id|. If stream was not found, returns NULL.\n\n Returns imaginary root stream (see\n `nghttp2_session_get_root_stream()`) if 0 is given in |stream_id|.\n\n Unless |stream_id| == 0, the returned pointer is valid until next\n call of `nghttp2_session_send()`, `nghttp2_session_mem_send2()`,\n `nghttp2_session_recv()`, and `nghttp2_session_mem_recv2()`."]
2181 pub fn nghttp2_session_find_stream(
2182 session: *mut nghttp2_session,
2183 stream_id: i32,
2184 ) -> *mut nghttp2_stream;
2185}
2186#[doc = " idle state."]
2187pub const NGHTTP2_STREAM_STATE_IDLE: nghttp2_stream_proto_state = 1;
2188#[doc = " open state."]
2189pub const NGHTTP2_STREAM_STATE_OPEN: nghttp2_stream_proto_state = 2;
2190#[doc = " reserved (local) state."]
2191pub const NGHTTP2_STREAM_STATE_RESERVED_LOCAL: nghttp2_stream_proto_state = 3;
2192#[doc = " reserved (remote) state."]
2193pub const NGHTTP2_STREAM_STATE_RESERVED_REMOTE: nghttp2_stream_proto_state = 4;
2194#[doc = " half closed (local) state."]
2195pub const NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL: nghttp2_stream_proto_state =
2196 5;
2197#[doc = " half closed (remote) state."]
2198pub const NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE: nghttp2_stream_proto_state =
2199 6;
2200#[doc = " closed state."]
2201pub const NGHTTP2_STREAM_STATE_CLOSED: nghttp2_stream_proto_state = 7;
2202#[doc = " @enum\n\n State of stream as described in RFC 7540."]
2203pub type nghttp2_stream_proto_state = u32;
2204unsafe extern "C" {
2205 #[doc = " @function\n\n Returns state of |stream|. The root stream retrieved by\n `nghttp2_session_get_root_stream()` will have stream state\n :enum:`nghttp2_stream_proto_state.NGHTTP2_STREAM_STATE_IDLE`."]
2206 pub fn nghttp2_stream_get_state(
2207 stream: *mut nghttp2_stream,
2208 ) -> nghttp2_stream_proto_state;
2209}
2210unsafe extern "C" {
2211 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n Returns root of dependency tree, which is imaginary stream with\n stream ID 0. The returned pointer is valid until |session| is\n freed by `nghttp2_session_del()`."]
2212 pub fn nghttp2_session_get_root_stream(
2213 session: *mut nghttp2_session,
2214 ) -> *mut nghttp2_stream;
2215}
2216unsafe extern "C" {
2217 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns NULL."]
2218 pub fn nghttp2_stream_get_parent(
2219 stream: *mut nghttp2_stream,
2220 ) -> *mut nghttp2_stream;
2221}
2222unsafe extern "C" {
2223 pub fn nghttp2_stream_get_stream_id(stream: *mut nghttp2_stream) -> i32;
2224}
2225unsafe extern "C" {
2226 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns NULL."]
2227 pub fn nghttp2_stream_get_next_sibling(
2228 stream: *mut nghttp2_stream,
2229 ) -> *mut nghttp2_stream;
2230}
2231unsafe extern "C" {
2232 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns NULL."]
2233 pub fn nghttp2_stream_get_previous_sibling(
2234 stream: *mut nghttp2_stream,
2235 ) -> *mut nghttp2_stream;
2236}
2237unsafe extern "C" {
2238 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns NULL."]
2239 pub fn nghttp2_stream_get_first_child(
2240 stream: *mut nghttp2_stream,
2241 ) -> *mut nghttp2_stream;
2242}
2243unsafe extern "C" {
2244 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns :macro:`NGHTTP2_DEFAULT_WEIGHT`."]
2245 pub fn nghttp2_stream_get_weight(stream: *mut nghttp2_stream) -> i32;
2246}
2247unsafe extern "C" {
2248 #[doc = " @function\n\n .. warning::\n\n Deprecated. :rfc:`7540` priorities are deprecated by\n :rfc:`9113`. Consider migrating to :rfc:`9218` extensible\n prioritization scheme.\n\n This function always returns 0."]
2249 pub fn nghttp2_stream_get_sum_dependency_weight(
2250 stream: *mut nghttp2_stream,
2251 ) -> i32;
2252}