= libnng(3)
|
//
|
// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
|
// Copyright 2018 Capitar IT Group BV <info@capitar.com>
|
// Copyright 2019 Devolutions <info@devolutions.net>
|
// Copyright 2020 Dirac Research <robert.bielik@dirac.com>
|
//
|
// This document is supplied under the terms of the MIT License, a
|
// copy of which should be located in the distribution where this
|
// file was obtained (LICENSE.txt). A copy of the license may also be
|
// found online at https://opensource.org/licenses/MIT.
|
//
|
|
== NAME
|
|
libnng - nanomsg next generation library
|
|
== SYNOPSIS
|
|
*cc* [_flags_] _files_ *-lnng* [_libraries_]
|
|
== DESCRIPTION
|
|
xref:nng.7.adoc[_NNG_] provides a common messaging framework
|
intended to solve common communication problems in distributed applications.
|
|
It provides a C language API.
|
|
=== Common Functions
|
|
The following common functions exist in _libnng_.
|
|
|===
|
|xref:nng_alloc.3.adoc[nng_alloc()]|allocate memory
|
|xref:nng_free.3.adoc[nng_free()]|free memory
|
|xref:nng_strdup.3.adoc[nng_strdup()]|duplicate string
|
|xref:nng_strerror.3.adoc[nng_strerror()]|return an error description
|
|xref:nng_strfree.3.adoc[nng_strfree()]|free string
|
|xref:nng_version.3.adoc[nng_version()]|report library version
|
|===
|
|
=== Socket Functions
|
|
The following functions operate on sockets.
|
|
|===
|
|xref:nng_close.3.adoc[nng_close()]|close socket
|
|xref:nng_dial.3.adoc[nng_dial()]|create and start dialer
|
|xref:nng_getopt.3.adoc[nng_getopt()]|get socket option
|
|xref:nng_listen.3.adoc[nng_listen()]|create and start listener
|
|xref:nng_recv.3.adoc[nng_recv()]|receive data
|
|xref:nng_send.3.adoc[nng_send()]|send data
|
|xref:nng_setopt.3.adoc[nng_setopt()]|set socket option
|
|xref:nng_socket_get.3.adoc[nng_socket_get()]|get socket option
|
|xref:nng_socket_id.3.adoc[nng_socket_id()]|get numeric socket identifier
|
|xref:nng_socket_set.3.adoc[nng_socket_set()]|set socket option
|
|===
|
|
=== Connection Management
|
|
The following functions are used with either listeners, or dialers.
|
Listeners accept incoming connection requests, and dialers make them.
|
|
|===
|
|xref:nng_dial.3.adoc[nng_dial()]|create and start dialer
|
|xref:nng_dialer_close.3.adoc[nng_dialer_close()]|close dialer
|
|xref:nng_dialer_create.3.adoc[nng_dialer_create()]|create dialer
|
|xref:nng_dialer_get.3.adoc[nng_dialer_get()]|get dialer option
|
|xref:nng_dialer_getopt.3.adoc[nng_dialer_getopt()]|get dialer option
|
|xref:nng_dialer_id.3.adoc[nng_dialer_id()]|get numeric dialer identifier
|
|xref:nng_dialer_set.3.adoc[nng_dialer_set()]|set dialer option
|
|xref:nng_dialer_setopt.3.adoc[nng_dialer_setopt()]|set dialer option
|
|xref:nng_dialer_start.3.adoc[nng_dialer_start()]|start dialer
|
|xref:nng_listen.3.adoc[nng_listen()]|create and start listener
|
|xref:nng_listener_close.3.adoc[nng_listener_close()]|close listener
|
|xref:nng_listener_create.3.adoc[nng_listener_create()]|create listener
|
|xref:nng_listener_get.3.adoc[nng_listener_get()]|get listener option
|
|xref:nng_listener_getopt.3.adoc[nng_listener_getopt()]|get listener option
|
|xref:nng_listener_id.3.adoc[nng_listener_id()]|get numeric listener identifier
|
|xref:nng_listener_set.3.adoc[nng_listener_set()]|set listener option
|
|xref:nng_listener_setopt.3.adoc[nng_listener_setopt()]|set listener option
|
|xref:nng_listener_start.3.adoc[nng_listener_start()]|start listener
|
|xref:nng_pipe_close.3.adoc[nng_pipe_close()]|close pipe
|
|xref:nng_pipe_dialer.3.adoc[nng_pipe_dialer()]|return dialer that created pipe
|
|xref:nng_pipe_get.3.adoc[nng_pipe_get()]|get pipe option
|
|xref:nng_pipe_getopt.3.adoc[nng_pipe_getopt()]|get pipe option
|
|xref:nng_pipe_id.3.adoc[nng_pipe_id()]|get numeric pipe identifier
|
|xref:nng_pipe_listener.3.adoc[nng_pipe_listener()]|return listener that created pipe
|
|xref:nng_pipe_notify.3.adoc[nng_pipe_notify()]|register pipe notification callback
|
|xref:nng_pipe_socket.3.adoc[nng_pipe_socket()]|return owning socket for pipe
|
|===
|
|
=== Message Handling Functions
|
|
Applications desiring to use the richest part of _libnng_ will want to
|
use the message API, where a message structure is passed between functions.
|
This API provides the most power support for zero-copy.
|
|
Messages are divided into a header and body, where the body generally carries
|
user-payload and the header carries protocol specific header information.
|
Most applications will only interact with the body.
|
|
|===
|
|xref:nng_msg_alloc.3.adoc[nng_msg_alloc()]|allocate a message
|
|xref:nng_msg_append.3.adoc[nng_msg_append()]|append to message body
|
|xref:nng_msg_body.3.adoc[nng_msg_body()]|return message body
|
|xref:nng_msg_capacity.3.adoc[nng_msg_capacity()]|return capacity allocated for message body
|
|xref:nng_msg_chop.3.adoc[nng_msg_chop()]|remove data from end of message body
|
|xref:nng_msg_clear.3.adoc[nng_msg_clear()]|clear message body
|
|xref:nng_msg_dup.3.adoc[nng_msg_dup()]|duplicate a message
|
|xref:nng_msg_free.3.adoc[nng_msg_free()]|free a message
|
|xref:nng_msg_get_pipe.3.adoc[nng_msg_get_pipe()]|get pipe for message
|
|xref:nng_msg_insert.3.adoc[nng_msg_insert()]|prepend to message body
|
|xref:nng_msg_len.3.adoc[nng_msg_len()]|return the message body length
|
|xref:nng_msg_realloc.3.adoc[nng_msg_realloc()]|reallocate a message
|
|xref:nng_msg_reserve.3.adoc[nng_msg_reserve()]|reserve storage for message body
|
|xref:nng_msg_set_pipe.3.adoc[nng_msg_set_pipe()]|set pipe for message
|
|xref:nng_msg_trim.3.adoc[nng_msg_trim()]|remove data from start of message body
|
|xref:nng_recvmsg.3.adoc[nng_recvmsg()]|receive a message
|
|xref:nng_sendmsg.3.adoc[nng_sendmsg()]|send a message
|
|===
|
|
==== Message Header Handling
|
|
TIP: Few applications will need these functions, as message headers are only
|
used to carry protocol-specific content. However, applications which use raw
|
mode may need to access the header of messages.
|
|
|===
|
|xref:nng_msg_header.3.adoc[nng_msg_header()]|return message header
|
|xref:nng_msg_header_append.3.adoc[nng_msg_header_append()]|append to message header
|
|xref:nng_msg_header_chop.3.adoc[nng_msg_header_chop()]|remove data from end of message header
|
|xref:nng_msg_header_clear.3.adoc[nng_msg_header_clear()]|clear message header
|
|xref:nng_msg_header_insert.3.adoc[nng_msg_header_insert()]|prepend to message header
|
|xref:nng_msg_header_len.3.adoc[nng_msg_header_len()]|return the message header length
|
|xref:nng_msg_header_trim.3.adoc[nng_msg_header_trim()]|remove data from start of message header
|
|===
|
|
=== Asynchronous Operations
|
|
Most applications will interact with _NNG_ synchronously; that is that
|
functions such as xref:nng_send.3.adoc[`nng_send()`] will block the calling
|
thread until the operation has completed.
|
|
NOTE: Synchronous operations which send messages may return before the
|
message has actually been received, or even transmitted. Instead, These
|
functions return as soon as the message was successfully queued for
|
delivery.
|
|
Asynchronous operations behave differently. These operations are
|
initiated by the calling thread, but control returns immediately to
|
the calling thread. When the operation is subsequently completed (regardless
|
of whether this was successful or not), then a user supplied function
|
is executed.
|
|
A context structure, an xref:nng_aio.5.adoc[`nng_aio`], is allocated and
|
associated with each asynchronous operation.
|
Only a single asynchronous operation may be associated with an
|
`nng_aio` at any time.
|
|
The following functions are used in the asynchronous model:
|
|
|===
|
|xref:nng_aio_abort.3.adoc[nng_aio_abort()]|abort asynchronous I/O operation
|
|xref:nng_aio_alloc.3.adoc[nng_aio_alloc()]|allocate asynchronous I/O handle
|
|xref:nng_aio_begin.3.adoc[nng_aio_begin()]|begin asynchronous I/O operation
|
|xref:nng_aio_cancel.3.adoc[nng_aio_cancel()]|cancel asynchronous I/O operation
|
|xref:nng_aio_count.3.adoc[nng_aio_count()]|return number of bytes transferred
|
|xref:nng_aio_defer.3.adoc[nng_aio_defer()]|defer asynchronous I/O operation
|
|xref:nng_aio_finish.3.adoc[nng_aio_finish()]|finish asynchronous I/O operation
|
|xref:nng_aio_free.3.adoc[nng_aio_free()]|free asynchronous I/O handle
|
|xref:nng_aio_get_input.3.adoc[nng_aio_get_input()]|return input parameter
|
|xref:nng_aio_get_msg.3.adoc[nng_aio_get_msg()]|get message from an asynchronous receive
|
|xref:nng_aio_get_output.3.adoc[nng_aio_get_output()]|return output result
|
|xref:nng_aio_free.3.adoc[nng_aio_reap()]|reap asynchronous I/O handle
|
|xref:nng_aio_result.3.adoc[nng_aio_result()]|return result of asynchronous operation
|
|xref:nng_aio_set_input.3.adoc[nng_aio_set_input()]|set input parameter
|
|xref:nng_aio_set_iov.3.adoc[nng_aio_set_iov()]|set scatter/gather vector
|
|xref:nng_aio_set_msg.3.adoc[nng_aio_set_msg()]|set message for an asynchronous send
|
|xref:nng_aio_set_output.3.adoc[nng_aio_set_output()]|set output result
|
|xref:nng_aio_set_timeout.3.adoc[nng_aio_set_timeout()]|set asynchronous I/O timeout
|
|xref:nng_aio_stop.3.adoc[nng_aio_stop()]|stop asynchronous I/O operation
|
|xref:nng_aio_wait.3.adoc[nng_aio_wait()]|wait for asynchronous I/O operation
|
|xref:nng_recv_aio.3.adoc[nng_recv_aio()]|receive message asynchronously
|
|xref:nng_send_aio.3.adoc[nng_send_aio()]|send message asynchronously
|
|xref:nng_sleep_aio.3.adoc[nng_sleep_aio()]|sleep asynchronously
|
|===
|
|
=== Protocols
|
|
The following functions are used to construct a socket with a specific protocol:
|
|
|===
|
|xref:nng_bus_open.3.adoc[nng_bus_open()]|open a bus socket
|
|xref:nng_pair_open.3.adoc[nng_pair_open()]|open a pair socket
|
|xref:nng_pub_open.3.adoc[nng_pub_open()]|open a pub socket
|
|xref:nng_pull_open.3.adoc[nng_pull_open()]|open a pull socket
|
|xref:nng_push_open.3.adoc[nng_push_open()]|open a push socket
|
|xref:nng_rep_open.3.adoc[nng_rep_open()]|open a rep socket
|
|xref:nng_req_open.3.adoc[nng_req_open()]|open a req socket
|
|xref:nng_respondent_open.3.adoc[nng_respondent_open()]|open a respondent socket
|
|xref:nng_sub_open.3.adoc[nng_sub_open()]|open a sub socket
|
|xref:nng_surveyor_open.3.adoc[nng_surveyor_open()]|open a surveyor socket
|
|===
|
|
=== Transports
|
|
The following functions are used to register a transport for use.
|
|
|===
|
| xref:nng_inproc_register.3.adoc[nng_inproc_register()]|register inproc transport
|
| xref:nng_ipc_register.3.adoc[nng_ipc_register()]|register IPC transport
|
| xref:nng_tcp_register.3.adoc[nng_tcp_register()]|register TCP transport
|
| xref:nng_tls_register.3.adoc[nng_tls_register()]|register TLS transport
|
| xref:nng_ws_register.3.adoc[nng_ws_register()]|register WebSocket transport
|
| xref:nng_wss_register.3.adoc[nng_wss_register()]|register WebSocket Secure transport
|
| xref:nng_zt_register.3.adoc[nng_zt_register()]|register ZeroTier transport
|
|===
|
|
=== Protocol Contexts
|
|
The following functions are useful to separate the protocol processing
|
from a socket object, into a separate context.
|
This can allow multiple contexts to be created on a single socket for
|
concurrent applications.
|
|
|===
|
|xref:nng_ctx_close.3.adoc[nng_ctx_close()]|close context
|
|xref:nng_ctx_get.3.adoc[nng_ctx_get()]|get context option
|
|xref:nng_ctx_getopt.3.adoc[nng_ctx_getopt()]|get context option
|
|xref:nng_ctx_id.3.adoc[nng_ctx_id()]|get numeric context identifier
|
|xref:nng_ctx_open.3.adoc[nng_ctx_open()]|create context
|
|xref:nng_ctx_recv.3.adoc[nng_ctx_recv()]|receive message using context asynchronously
|
|xref:nng_ctx_send.3.adoc[nng_ctx_send()]|send message using context asynchronously
|
|xref:nng_ctx_set.3.adoc[nng_ctx_set()]|set context option
|
|xref:nng_ctx_setopt.3.adoc[nng_ctx_setopt()]|set context option
|
|===
|
|
=== Statistics
|
|
The following functions provide access to statistics which can be used
|
to observe program behaviors and as an aid in troubleshooting.
|
|
|===
|
|xref:nng_stat_bool.3.adoc[nng_stat_bool()]|get statistic Boolean value
|
|xref:nng_stat_child.3.adoc[nng_stat_child()]|get child statistic
|
|xref:nng_stat_desc.3.adoc[nng_stat_name()]|get statistic description
|
|xref:nng_stat_find.3.adoc[nng_stat_find()]|find statistic by name
|
|xref:nng_stat_find_dialer.3.adoc[nng_stat_find_dialer()]|find dialer statistics
|
|xref:nng_stat_find_listener.3.adoc[nng_stat_find_listener()]|find listener statistics
|
|xref:nng_stat_find_socket.3.adoc[nng_stat_find_socket()]|find socket statistics
|
|xref:nng_stat_name.3.adoc[nng_stat_name()]|get statistic name
|
|xref:nng_stat_next.3.adoc[nng_stat_next()]|get next statistic
|
|xref:nng_stat_string.3.adoc[nng_stat_string()]|get statistic string value
|
|xref:nng_stat_timestamp.3.adoc[nng_stat_timestamp()]|get statistic timestamp
|
|xref:nng_stat_type.3.adoc[nng_stat_type()]|get statistic type
|
|xref:nng_stat_unit.3.adoc[nng_stat_unit()]|get statistic unit
|
|xref:nng_stat_value.3.adoc[nng_stat_value()]|get statistic numeric value
|
|xref:nng_stats_free.3.adoc[nng_stats_free()]|free statistics
|
|xref:nng_stats_get.3.adoc[nng_stats_get()]|get statistics
|
|===
|
|
=== URL Object
|
|
Common functionality is supplied for parsing and handling
|
universal resource locators (URLS).
|
|
|===
|
|xref:nng_url_clone.3.adoc[nng_url_clone()]|clone URL structure
|
|xref:nng_url_free.3.adoc[nng_url_free()]|free URL structure
|
|xref:nng_url_parse.3.adoc[nng_url_parse()]|create URL structure from string
|
|===
|
|
|
=== Supplemental API
|
|
These supplemental functions are not intrinsic to building
|
network applications with _NNG_, but they are made available
|
as a convenience to aid in creating portable applications.
|
|
|===
|
|xref:nng_clock.3supp.adoc[nng_clock()]|get time
|
|xref:nng_cv_alloc.3supp.adoc[nng_cv_alloc()]|allocate condition variable
|
|xref:nng_cv_free.3supp.adoc[nng_cv_free()]|free condition variable
|
|xref:nng_cv_until.3supp.adoc[nng_cv_until()]|wait for condition or timeout
|
|xref:nng_cv_wait.3supp.adoc[nng_cv_wait()]|wait for condition
|
|xref:nng_cv_wake.3supp.adoc[nng_cv_wake()]|wake all waiters
|
|xref:nng_cv_wake1.3supp.adoc[nng_cv_wake1()]|wake one waiter
|
|xref:nng_msleep.3supp.adoc[nng_msleep()]|sleep for milliseconds
|
|xref:nng_mtx_alloc.3supp.adoc[nng_mtx_alloc()]|allocate mutex
|
|xref:nng_mtx_free.3supp.adoc[nng_mtx_free()]|free mutex
|
|xref:nng_mtx_lock.3supp.adoc[nng_mtx_lock()]|lock mutex
|
|xref:nng_mtx_unlock.3supp.adoc[nng_mtx_unlock()]|unlock mutex
|
|xref:nng_opts_parse.3supp.adoc[nng_opts_parse()]|parse command line options
|
|xref:nng_random.3supp.adoc[nng_random()]|get random number
|
|xref:nng_thread_create.3supp.adoc[nng_thread_create()]|create thread
|
|xref:nng_thread_destroy.3supp.adoc[nng_thread_destroy()]|reap thread
|
|xref:nng_thread_set_name.3supp.adoc[nng_thread_set_name()]|set thread name
|
|===
|
|
=== Byte Streams
|
|
These functions are available for use with byte streams.
|
They are considered low-level, for uses where the higher level functions
|
using Scalability Protocols are inappropriate.
|
|
Byte streams, represented by
|
xref:nng_stream.5.adoc[`nng_stream`] objects, correspond to underlying
|
connections such as TCP connections or named pipes.
|
They are created by either
|
xref:nng_stream_dialer.5.adoc[`nng_stream_dialer`] or
|
xref:nng_stream_listener.5.adoc[`nng_stream_listener`] objects.
|
|
|===
|
|xref:nng_stream_close.3str.adoc[nng_stream_close()]|close byte stream
|
|xref:nng_stream_dialer_alloc.3str.adoc[nng_stream_dialer_alloc()]|allocate byte stream dialer
|
|xref:nng_stream_dialer_close.3str.adoc[nng_stream_dialer_close()]|close byte stream dialer
|
|xref:nng_stream_dialer_dial.3str.adoc[nng_stream_dialer_dial()]|initiate outgoing byte stream
|
|xref:nng_stream_dialer_free.3str.adoc[nng_stream_dialer_free()]|free byte stream dialer
|
|xref:nng_stream_dialer_get.3str.adoc[nng_stream_dialer_get()]|get option from byte stream dialer
|
|xref:nng_stream_dialer_set.3str.adoc[nng_stream_dialer_set()]|set option on byte stream dialer
|
|xref:nng_stream_free.3str.adoc[nng_stream_free()]|free byte stream
|
|xref:nng_stream_get.3str.adoc[nng_stream_get()]|get option from byte stream
|
|xref:nng_stream_listener_accept.3str.adoc[nng_stream_listener_accept()]|accept incoming byte stream
|
|xref:nng_stream_listener_alloc.3str.adoc[nng_stream_listener_alloc()]|allocate byte stream listener
|
|xref:nng_stream_listener_close.3str.adoc[nng_stream_listener_close()]|close byte stream listener
|
|xref:nng_stream_listener_free.3str.adoc[nng_stream_listener_free()]|free byte stream listener
|
|xref:nng_stream_listener_get.3str.adoc[nng_stream_listener_get()]|get option from byte stream listener
|
|xref:nng_stream_listener_listen.3str.adoc[nng_stream_listener_listen()]|bind byte stream listener to address
|
|xref:nng_stream_listener_set.3str.adoc[nng_stream_listener_set()]|set option on byte stream listener
|
|xref:nng_stream_recv.3str.adoc[nng_stream_recv()]|receive from byte stream
|
|xref:nng_stream_send.3str.adoc[nng_stream_send()]|send to byte stream
|
|xref:nng_stream_set.3str.adoc[nng_stream_set()]|set option on byte stream
|
|===
|
|
=== HTTP Support
|
|
The library may be configured with support for HTTP, and this will
|
be the case if WebSocket support is configured as well.
|
In this case, it is possible to access functionality to support the creation of
|
HTTP (and HTTP/S if TLS support is present) servers and clients.
|
|
==== Common HTTP Functions
|
|
The following functions are used to work with HTTP requests, responses,
|
and connections.
|
|
|===
|
|xref:nng_http_conn_close.3http.adoc[nng_http_conn_close()]|close HTTP connection
|
|xref:nng_http_conn_read.3http.adoc[nng_http_conn_read()]|read from HTTP connection
|
|xref:nng_http_conn_read_all.3http.adoc[nng_http_conn_read_all()]|read all from HTTP connection
|
|xref:nng_http_conn_read_req.3http.adoc[nng_http_conn_read_req()]|read HTTP request
|
|xref:nng_http_conn_read_res.3http.adoc[nng_http_conn_read_res()]|read HTTP response
|
|xref:nng_http_conn_write.3http.adoc[nng_http_conn_write()]|write to HTTP connection
|
|xref:nng_http_conn_write_all.3http.adoc[nng_http_conn_write_all()]|write all to HTTP connection
|
|xref:nng_http_conn_write_req.3http.adoc[nng_http_conn_write_req()]|write HTTP request
|
|xref:nng_http_conn_write_res.3http.adoc[nng_http_conn_write_res()]|write HTTP response
|
|xref:nng_http_req_add_header.3http.adoc[nng_http_req_add_header()]|add HTTP request header
|
|xref:nng_http_req_alloc.3http.adoc[nng_http_req_alloc()]|allocate HTTP request structure
|
|xref:nng_http_req_copy_data.3http.adoc[nng_http_req_copy_data()]|copy HTTP request body
|
|xref:nng_http_req_del_header.3http.adoc[nng_http_req_del_header()]|delete HTTP request header
|
|xref:nng_http_req_free.3http.adoc[nng_http_req_free()]|free HTTP request structure
|
|xref:nng_http_req_get_data.3http.adoc[nng_http_req_get_data()]|get HTTP request body
|
|xref:nng_http_req_get_header.3http.adoc[nng_http_req_get_header()]|return HTTP request header
|
|xref:nng_http_req_get_method.3http.adoc[nng_http_req_get_method()]|return HTTP request method
|
|xref:nng_http_req_get_uri.3http.adoc[nng_http_req_get_uri()]|return HTTP request URI
|
|xref:nng_http_req_get_version.3http.adoc[nng_http_req_get_version()]|return HTTP request protocol version
|
|xref:nng_http_req_reset.3http.adoc[nng_http_req_reset()]|reset HTTP request structure
|
|xref:nng_http_req_set_data.3http.adoc[nng_http_req_set_data()]|set HTTP request body
|
|xref:nng_http_req_set_header.3http.adoc[nng_http_req_set_header()]|set HTTP request header
|
|xref:nng_http_req_set_method.3http.adoc[nng_http_req_set_method()]|set HTTP request method
|
|xref:nng_http_req_set_uri.3http.adoc[nng_http_req_set_uri()]|set HTTP request URI
|
|xref:nng_http_req_set_version.3http.adoc[nng_http_req_set_version()]|set HTTP request protocol version
|
|xref:nng_http_res_add_header.3http.adoc[nng_http_res_add_header()]|add HTTP response header
|
|xref:nng_http_res_alloc.3http.adoc[nng_http_res_alloc()]|allocate HTTP response structure
|
|xref:nng_http_res_alloc_error.3http.adoc[nng_http_res_alloc_error()]|allocate HTTP error response
|
|xref:nng_http_res_copy_data.3http.adoc[nng_http_res_copy_data()]|copy HTTP response body
|
|xref:nng_http_res_del_header.3http.adoc[nng_http_res_del_header()]|delete HTTP response header
|
|xref:nng_http_res_free.3http.adoc[nng_http_res_free()]|free HTTP response structure
|
|xref:nng_http_res_get_data.3http.adoc[nng_http_res_get_data()]|get HTTP response body
|
|xref:nng_http_res_get_header.3http.adoc[nng_http_res_get_header()]|return HTTP response header
|
|xref:nng_http_res_get_reason.3http.adoc[nng_http_res_get_reason()]|return HTTP response reason
|
|xref:nng_http_res_get_status.3http.adoc[nng_http_res_get_status()]|return HTTP response status
|
|xref:nng_http_res_get_version.3http.adoc[nng_http_res_get_version()]|return HTTP response protocol version
|
|xref:nng_http_res_reset.3http.adoc[nng_http_res_reset()]|reset HTTP response structure
|
|xref:nng_http_res_set_data.3http.adoc[nng_http_res_set_data()]|set HTTP response body
|
|xref:nng_http_res_set_header.3http.adoc[nng_http_res_set_header()]|set HTTP response header
|
|xref:nng_http_res_set_reason.3http.adoc[nng_http_res_set_reason()]|set HTTP response reason
|
|xref:nng_http_res_set_status.3http.adoc[nng_http_res_set_status()]|set HTTP response status
|
|xref:nng_http_res_set_version.3http.adoc[nng_http_res_set_version()]|set HTTP response protocol version
|
|===
|
|
==== HTTP Client Functions
|
|
These functions are intended for use with HTTP client applications.
|
|
|===
|
|xref:nng_http_client_alloc.3http.adoc[nng_http_client_alloc()]|allocate HTTP client
|
|xref:nng_http_client_connect.3http.adoc[nng_http_client_connect()]|establish HTTP client connection
|
|xref:nng_http_client_free.3http.adoc[nng_http_client_free()]|free HTTP client
|
|xref:nng_http_client_get_tls.3http.adoc[nng_http_client_get_tls()]|get HTTP client TLS configuration
|
|xref:nng_http_client_set_tls.3http.adoc[nng_http_client_set_tls()]|set HTTP client TLS configuration
|
|xref:nng_http_client_transact.3http.adoc[nng_http_client_transact()]|perform one HTTP transaction
|
|xref:nng_http_conn_transact.3http.adoc[nng_http_conn_transact()]|perform one HTTP transaction on connection
|
|===
|
|
==== HTTP Server Functions
|
|
These functions are intended for use with HTTP server applications.
|
|
|===
|
|xref:nng_http_handler_alloc.3http.adoc[nng_http_handler_alloc()]|allocate HTTP server handler
|
|xref:nng_http_handler_collect_body.3http.adoc[nng_http_handler_collect_body()]|set HTTP handler to collect request body
|
|xref:nng_http_handler_free.3http.adoc[nng_http_handler_free()]|free HTTP server handler
|
|xref:nng_http_handler_get_data.3http.adoc[nng_http_handler_get_data()]|return extra data for HTTP handler
|
|xref:nng_http_handler_set_data.3http.adoc[nng_http_handler_set_data()]|set extra data for HTTP handler
|
|xref:nng_http_handler_set_host.3http.adoc[nng_http_handler_set_host()]|set host for HTTP handler
|
|xref:nng_http_handler_set_method.3http.adoc[nng_http_handler_set_method()]|set HTTP handler method
|
|xref:nng_http_handler_set_tree.3http.adoc[nng_http_handler_set_tree()]|set HTTP handler to match trees
|
|xref:nng_http_hijack.3http.adoc[nng_http_hijack()]|hijack HTTP server connection
|
|xref:nng_http_server_add_handler.3http.adoc[nng_http_server_add_handler()]|add HTTP server handler
|
|xref:nng_http_server_del_handler.3http.adoc[nng_http_server_del_handler()]|delete HTTP server handler
|
|xref:nng_http_server_get_addr.3http.adoc[nng_http_server_get_addr()]|get HTTP server address
|
|xref:nng_http_server_get_tls.3http.adoc[nng_http_server_get_tls()]|get HTTP server TLS configuration
|
|xref:nng_http_server_hold.3http.adoc[nng_http_server_hold()]|get and hold HTTP server instance
|
|xref:nng_http_server_release.3http.adoc[nng_http_server_release()]|release HTTP server instance
|
|xref:nng_http_server_set_error_file.3http.adoc[nng_http_server_set_error_file()]|set custom HTTP error file
|
|xref:nng_http_server_set_error_page.3http.adoc[nng_http_server_set_error_page()]|set custom HTTP error page
|
|xref:nng_http_server_set_tls.3http.adoc[nng_http_server_set_tls()]|set HTTP server TLS configuration
|
|xref:nng_http_server_res_error.3http.adoc[nng_http_server_res_error()]|use HTTP server error page
|
|xref:nng_http_server_start.3http.adoc[nng_http_server_start()]|start HTTP server
|
|xref:nng_http_server_stop.3http.adoc[nng_http_server_stop()]|stop HTTP server
|
|===
|
|
=== TLS Configuration Objects
|
|
The following functions are used to manipulate transport layer security
|
(TLS) configuration objects. Most of these functions will not be used even
|
by TLS applications.
|
|
NOTE: These functions will only be present if the library has been built
|
with TLS support.
|
|
|===
|
|xref:nng_tls_config_alloc.3tls.adoc[nng_tls_config_alloc()]|allocate TLS configuration
|
|xref:nng_tls_config_auth_mode.3tls.adoc[nng_tls_config_auth_mode()]|set authentication mode
|
|xref:nng_tls_config_ca_chain.3tls.adoc[nng_tls_config_ca_chain()]|set certificate authority chain
|
|xref:nng_tls_config_ca_file.3tls.adoc[nng_tls_config_ca_file()]|load certificate authority from file
|
|xref:nng_tls_config_cert_key_file.3tls.adoc[nng_tls_config_cert_key_file()]|load own certificate and key from file
|
|xref:nng_tls_config_own_cert.3tls.adoc[nng_tls_config_own_cert()]|set own certificate and key
|
|xref:nng_tls_config_free.3tls.adoc[nng_tls_config_free()]|free TLS configuration
|
|xref:nng_tls_config_server_name.3tls.adoc[nng_tls_config_server_name()]|set remote server name
|
|===
|
|
|
== SEE ALSO
|
|
[.text-left]
|
xref:nng_compat.3compat.adoc[nng_compat(3compat)],
|
xref:nng.7.adoc[nng(7)]
|
