From ecad76e6b96616d4b04a0af607830343427bf9fa Mon Sep 17 00:00:00 2001 From: Garrett D'Amore Date: Tue, 31 Dec 2024 17:44:57 -0800 Subject: [PATCH] docs: convert socket receive docs --- docs/man/nng_recv.3.adoc | 91 ------------------------------------ docs/man/nng_recv_aio.3.adoc | 81 -------------------------------- docs/man/nng_recvmsg.3.adoc | 71 ---------------------------- docs/ref/api/sock.md | 68 +++++++++++++++++++++++++++ 4 files changed, 68 insertions(+), 243 deletions(-) delete mode 100644 docs/man/nng_recv.3.adoc delete mode 100644 docs/man/nng_recv_aio.3.adoc delete mode 100644 docs/man/nng_recvmsg.3.adoc diff --git a/docs/man/nng_recv.3.adoc b/docs/man/nng_recv.3.adoc deleted file mode 100644 index ef1f2756a..000000000 --- a/docs/man/nng_recv.3.adoc +++ /dev/null @@ -1,91 +0,0 @@ -= nng_recv(3) -// -// Copyright 2018 Staysail Systems, Inc. -// Copyright 2018 Capitar IT Group BV -// -// 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 - -nng_recv - recv data - -== SYNOPSIS - -[source, c] ----- -#include - -int nng_recv(nng_socket s, void *data, size_t *sizep, int flags); ----- - -== DESCRIPTION - -The `nng_recv()` receives a message. - -The _flags_ is a bit mask that may contain any of the following values: - -`NNG_FLAG_NONBLOCK`:: - The function returns immediately, even if no message is available. - Without this flag, the function will wait until a message is received - by the socket _s_, or any configured timer expires. - -`NNG_FLAG_ALLOC`:: - If this flag is present, then a ((zero-copy)) mode is used. - In this case the caller must set the value of _data_ to the location - of another pointer (of type `void *`), and the _sizep_ pointer must be set - to a location to receive the size of the message body. - The function will then allocate a message buffer - (as if by xref:nng_alloc.3.adoc[`nng_alloc()`]), fill it with - the message body, and store it at the address referenced by _data_, and update - the size referenced by _sizep_. - The caller is responsible for disposing of the received buffer either by - the xref:nng_free.3.adoc[`nng_free()`] function or passing the message (also - with the `NNG_FLAG_ALLOC` flag) in a call to xref:nng_send.3.adoc[`nng_send()`]. - -If the special flag `NNG_FLAG_ALLOC` (see above) is not specified, then the -caller must set _data_ to a buffer to receive the message body content, -and must store the size of that buffer at the location pointed to by _sizep_. -When the function returns, if it is successful, the size at _sizep_ will be -updated with the actual message body length copied into _data_. - -NOTE: The semantics of what receiving a message means vary from protocol to -protocol, so examination of the protocol documentation is encouraged. -(For example, with a xref:nng_req.7.adoc[_req_] socket a message may only be received -after a request has been sent, and a xref:nng_sub.7.adoc[_sub_] socket -may only receive messages corresponding to topics to which it has subscribed.) -Furthermore, some protocols may not support receiving data at all, such as -xref:nng_pub.7.adoc[_pub_]. - -TIP: The `NNG_FLAG_ALLOC` flag can be used to reduce data copies, thereby -increasing performance, particularly if the buffer is reused to send -a response using the same flag. - -== RETURN VALUES - -This function returns 0 on success, and non-zero otherwise. - -== ERRORS - -[horizontal] -`NNG_EAGAIN`:: The operation would block, but `NNG_FLAG_NONBLOCK` was specified. -`NNG_ECLOSED`:: The socket _s_ is not open. -`NNG_EINVAL`:: An invalid set of _flags_ was specified. -`NNG_EMSGSIZE`:: The received message did not fit in the size provided. -`NNG_ENOMEM`:: Insufficient memory is available. -`NNG_ENOTSUP`:: The protocol for socket _s_ does not support receiving. -`NNG_ESTATE`:: The socket _s_ cannot receive data in this state. -`NNG_ETIMEDOUT`:: The operation timed out. - -== SEE ALSO - -[.text-left] -xref:nng_alloc.3.adoc[nng_alloc(3)], -xref:nng_free.3.adoc[nng_free(3)], -xref:nng_recvmsg.3.adoc[nng_recvmsg(3)], -xref:nng_send.3.adoc[nng_send(3)], -xref:nng_strerror.3.adoc[nng_strerror(3)], -xref:nng.7.adoc[nng(7)] diff --git a/docs/man/nng_recv_aio.3.adoc b/docs/man/nng_recv_aio.3.adoc deleted file mode 100644 index 4c9704898..000000000 --- a/docs/man/nng_recv_aio.3.adoc +++ /dev/null @@ -1,81 +0,0 @@ -= nng_recv_aio(3) -// -// Copyright 2018 Staysail Systems, Inc. -// Copyright 2018 Capitar IT Group BV -// -// 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 - -nng_recv_aio - receive message asynchronously - -== SYNOPSIS - -[source, c] ----- -#include - -void nng_recv_aio(nng_socket s, nng_aio *aio); ----- - -== DESCRIPTION - -The `nng_recv_aio()` receives a xref:nng_msg.5.adoc[message] using the -xref:nng_socket.5.adoc[socket] _s_ asynchronously. - -When a message is successfully received by the socket, it is -stored in the _aio_ by an internal call equivalent to -xref:nng_aio_set_msg.3.adoc[`nng_aio_set_msg()`], then the completion -callback on the _aio_ is executed. -In this case, xref:nng_aio_result.3.adoc[`nng_aio_result()`] will -return zero. -The callback function is responsible for retrieving the message -and disposing of it appropriately. - -IMPORTANT: Failing to accept and dispose of messages in this -case can lead to memory leaks. - -If for some reason the asynchronous receive cannot be completed -successfully (including by being canceled or timing out), then -the callback will still be executed, -but xref:nng_aio_result.3.adoc[`nng_aio_result()`] will be non-zero. - -NOTE: The semantics of what receiving a message means varies from protocol to -protocol, so examination of the protocol documentation is encouraged. -(For example, with a xref:nng_pub.7.adoc[_pub_] socket the data is broadcast, so that -any peers who have a suitable subscription will be able to receive it using -xref:nng_recv.3.adoc[`nng_recv()`] or a similar function.) -Furthermore, some protocols may not support receiving (such as -xref:nng_pub.7.adoc[_pub_]) or may require other conditions. -(For example, xref:nng_req.7.adoc[_req_] sockets cannot normally receive data, which -are replies to requests, until they have first sent a request.) - -== RETURN VALUES - -None. (The operation completes asynchronously.) - -== ERRORS - -[horizontal] -`NNG_ECANCELED`:: The operation was aborted. -`NNG_ECLOSED`:: The socket _s_ is not open. -`NNG_ENOMEM`:: Insufficient memory is available. -`NNG_ENOTSUP`:: The protocol for socket _s_ does not support receiving. -`NNG_ESTATE`:: The socket _s_ cannot receive data in this state. -`NNG_ETIMEDOUT`:: The receive timeout expired. - -== SEE ALSO - -[.text-left] -xref:nng_aio_get_msg.3.adoc[nng_aio_get_msg(3)], -xref:nng_aio_set_msg.3.adoc[nng_aio_set_msg(3)], -xref:nng_msg_alloc.3.adoc[nng_msg_alloc(3)], -xref:nng_strerror.3.adoc[nng_strerror(3)], -xref:nng_aio.5.adoc[nng_aio(5)], -xref:nng_msg.5.adoc[nng_msg(5)], -xref:nng_socket.5.adoc[nng_socket(5)], -xref:nng.7.adoc[nng(7)] diff --git a/docs/man/nng_recvmsg.3.adoc b/docs/man/nng_recvmsg.3.adoc deleted file mode 100644 index c502d6503..000000000 --- a/docs/man/nng_recvmsg.3.adoc +++ /dev/null @@ -1,71 +0,0 @@ -= nng_recvmsg(3) -// -// Copyright 2021 Staysail Systems, Inc. -// Copyright 2018 Capitar IT Group BV -// -// 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 - -nng_recvmsg - receive a message - -== SYNOPSIS - -[source, c] ----- -#include - -int nng_recvmsg(nng_socket s, nng_msg **msgp, int flags); ----- - -== DESCRIPTION - -The `nng_recvmsg()` receives a message on socket _s_, storing the -received message at the location pointed to by _msgp_. - -TIP: Using this function gives access to the message structure, and thus may -offer more functionality than the simpler xref:nng_recv.3.adoc[`nng_recv()`] function. - -The _flags_ may contain the following value: - -`NNG_FLAG_NONBLOCK`:: - The function returns immediately, even if no message is available. - Without this flag, the function will wait until a message is received - by the socket _s_, or any configured timer expires. - -NOTE: The semantics of what receiving a message means vary from protocol to -protocol, so examination of the protocol documentation is encouraged. -(For example, with an xref:nng_req.7.adoc[_req_] socket a message may only be received -after a request has been sent, and an xref:nng_sub.7.adoc[_sub_] socket -may only receive messages corresponding to topics to which it has subscribed.) -Furthermore, some protocols may not support receiving data at all, such as -xref:nng_pub.7.adoc[_pub_]. - -== RETURN VALUES - -This function returns 0 on success, and non-zero otherwise. - -== ERRORS - -[horizontal] -`NNG_EAGAIN`:: The operation would block, but `NNG_FLAG_NONBLOCK` was specified. -`NNG_ECLOSED`:: The socket _s_ is not open. -`NNG_EINVAL`:: An invalid set of _flags_ was specified. -`NNG_ENOMEM`:: Insufficient memory is available. -`NNG_ENOTSUP`:: The protocol for socket _s_ does not support receiving. -`NNG_ESTATE`:: The socket _s_ cannot receive data in this state. -`NNG_ETIMEDOUT`:: The operation timed out. - -== SEE ALSO - -[.text-left] -xref:nng_msg_free.3.adoc[nng_msg_free(3)], -xref:nng_recv.3.adoc[nng_recv(3)], -xref:nng_sendmsg.3.adoc[nng_sendmsg(3)], -xref:nng_strerror.3.adoc[nng_strerror(3)], -xref:nng_socket.5.adoc[nng_socket(5)], -xref:nng.7.adoc[nng(7)] diff --git a/docs/ref/api/sock.md b/docs/ref/api/sock.md index ede67c3ff..54aa65802 100644 --- a/docs/ref/api/sock.md +++ b/docs/ref/api/sock.md @@ -227,6 +227,74 @@ For example, the message may be sitting in queue, or located in TCP buffers, or > steps on the part of the application, the lowest latencies and highest performance will be achieved by using > this function instead of [`nng_send`] or [`nng_sendmsg`]. +## Receiving Messages + +```c +int nng_recv(nng_socket s, void *data, size_t *sizep, int flags); +int nng_recvmsg(nng_socket s, nng_msg **msgp, int flags); +void nng_recv_aio(nng_socket s, nng_aio *aio); +``` + +These functions ({{i:`nng_recv`}}, {{i:`nng_recvmsg`}}, and {{i:`nng_recv_aio`}}) receive +messages over the socket _s_. The differences in their behaviors are as follows. + +> [!NOTE] +> The semantics of what receving a message means varies from protocol to +> protocol, so examination of the protocol documentation is encouraged. +> Additionally, some protocols may not support receiving at all or may require other pre-conditions first. +> (For example, [REQ][req] sockets cannot normally receive data until they have first sent a request, +> while [PUB][pub] sockets can only send data and never receive it.) + +### nng_recv + +The `nng_recv` function is the simplest to use, but is the least efficient. +It receives the content in _data_, as a message size (in bytes) of up to the value stored in _sizep_, +unless the `NNG_FLAG_ALLOC` flag is set in _flags_ (see below.) + +Upon success, the size of the message received will be stored in _sizep_. + +The _flags_ is a bit mask made up of zero or more of the following values: + +- {{i:`NNG_FLAG_NONBLOCK`}}: + If the socket has no messages pending for reception at this time, it does not block, but returns immediately + with a status of [`NNG_EAGAIN`]. If this flag is absent, the function will wait until data can be received. + +- {{i:`NNG_FLAG_ALLOC`}}: + Instead of receiving the message into _data_, a new buffer will be allocated exactly large enough to hold + the message. A pointer to that buffer will be stored at the location specified by _data_. This provides a form + of zero-copy operation. The caller should dispose of the buffer using [`nng_free`] or by sending using + [`nng_send`] with the [`NNG_FLAG_ALLOC`] flag. + +> [!IMPORTANT] +> When using `NNG_FLAG_ALLOC`, it is important that the value of _size_ match the actual allocated size of the data. +> Using an incorrect size results in unspecified behavior, which may include heap corruption, program crashes, +> or other undesirable effects. + +### nng_recvmsg + +The `nng_recvmsg` function receives a message and stores a pointer to the [`nng_msg`] for that message in _msgp_. + +The _flags_ can contain the value [`NNG_FLAG_NONBLOCK`], indicating that the function should not wait if the socket +has no messages available to receive. In such a case, it will return [`NNG_EAGAIN`]. + +> [!TIP] +> This function is preferred over [`nng_recv`], as it gives access to the message structure and eliminates both +> a data copy and allocation, even when `nng_recv` is using `NNG_FLAG_ALLOC`. + +### nng_recv_aio + +The `nng_send_aio` function receives a message asynchronously, using the [`nng_aio`] _aio_, over the socket _s_. +On success, the received message can be retrieved from the _aio_ using the [`nng_aio_get_msg`] function. + +> [!NOTE] +> It is important that the application retrieves the message, and disposes of it accordingly. +> Failure to do so will leak the memory. + +> [!TIP] +> This is the preferred function to use for receiving data on a socket. While it does require a few extra +> steps on the part of the application, the lowest latencies and highest performance will be achieved by using +> this function instead of [`nng_recv`] or [`nng_recvmsg`]. + ## Polling Socket Events ```c