Skip to content

Instantly share code, notes, and snippets.

@genotrance

genotrance/nghttp2.nim

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