nng_close, nng_send, nng_recv

3 files changed, 155 insertions, 0 deletions

diff --git a/docs/ref/sock/nng_close.adoc b/docs/ref/sock/nng_close.adoc
new file mode 100644
index 00000000..29e93a49
--- /dev/null
+++ b/docs/ref/sock/nng_close.adoc
@@ -0,0 +1,32 @@
+## nng_close
+
+Close socket.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_close(nng_socket s);
+```
+
+### Description
+
+The `nng_close` function closes the supplied socket, _s_.
+Messages that have been submitted for sending may be flushed or delivered, depending upon the transport.
+
+Further attempts to use the socket after this call returns will result in `NNG_ECLOSED`.
+Threads waiting for operations on the socket when this call is executed may also return with an `NNG_ECLOSED` result.
+
+NOTE: Closing the socket while data is in transmission will likely lead to loss of that data.
+There is no automatic linger or flush to ensure that the socket send buffers have completely transmitted.
+It is recommended to wait a brief period after calling xref:nng_send.adoc[`nng_send`] or similar functions, before calling this function.
+
+### Return Values
+
+This function returns 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_ECLOSED`:: The socket _s_ is already closed or was never opened.
diff --git a/docs/ref/sock/nng_recv.adoc b/docs/ref/sock/nng_recv.adoc
new file mode 100644
index 00000000..a9bc0197
--- /dev/null
+++ b/docs/ref/sock/nng_recv.adoc
@@ -0,0 +1,59 @@
+## nng_recv
+
+Recv data.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+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:../util/nng_alloc.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:../util/nng_free.adoc[`nng_free`] function or passing the message (also with the `NNG_FLAG_ALLOC` flag) in a call to xref:nng_send.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.
+Furthermore, some protocols may not support receiving data at all, or may require other conditions be met before they can receive.
+
+TIP: The `NNG_FLAG_ALLOC` flag can be used to reduce data copies, thereby increasing performance.
+However the xref:nng_recvmsg.adoc[`nng_recvmsg`] function is even better, and should be preferred when possible.
+
+### 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
+
+xref:../util/nng_alloc.adoc[nng_alloc],
+xref:../util/nng_free.adoc[nng_free],
+xref:nng_recvmsg.adoc[nng_recvmsg],
+xref:nng_send.adoc[nng_send]
diff --git a/docs/ref/sock/nng_send.adoc b/docs/ref/sock/nng_send.adoc
new file mode 100644
index 00000000..ffb56e5b
--- /dev/null
+++ b/docs/ref/sock/nng_send.adoc
@@ -0,0 +1,64 @@
+## nng_send
+
+Send data.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_send(nng_socket s, void *data, size_t size, int flags);
+```
+
+### Description
+
+The `nng_send` function sends a message containing the _data_ of
+length _size_ using the xref:nng_socket.adoc[socket] _s_.
+
+NOTE: The semantics of what receiving a message means vary from protocol to protocol, so examination of the protocol documentation is encouraged.
+Furthermore, some protocols may not support sending data at all, or may require other conditions be met before they can send.
+
+The _flags_ may contain either of (or neither of) the following values:
+
+((`NNG_FLAG_NONBLOCK`))::
+    The function returns immediately, regardless of whether the socket is able to accept the data or not.
+    If the socket is unable to accept the data (such as if backpressure exists because the peers are consuming messages too slowly, or no peer is present), then the function will return with `NNG_EAGAIN`.
+    If this flag is not specified, then the function will block if such a condition exists.
+
+((`NNG_FLAG_ALLOC`))::
+    The _data_ was allocated using xref:../util/nng_alloc.adoc[`nng_alloc`], or was obtained from a call to xref:nng_recv.adoc[`nng_recv`] with the `NNG_FLAG_ALLOC` flag.
+    If this function returns success, then the _data_ is "owned" by the function, and it will assume responsibility for calling xref:../util/nng_free.adoc[`nng_free`] when it is no longer needed.
+    In the absence of this flag, the _data_ is copied by the implementation before the function returns to the caller.
+
+TIP: The `NNG_FLAG_ALLOC` flag can be used to reduce data copies, thereby increasing performance.
+However the xref:nng_sendmsg.adoc[`nng_sendmsg`] function is even better, and should be preferred when possible.
+
+NOTE: Regardless of the presence or absence of `NNG_FLAG_NONBLOCK`, there may be queues between the sender and the receiver.
+Furthermore, there is no guarantee that the message has actually been delivered.
+Finally, with some best-effort delivery only protocols, the semantic is implicitly `NNG_FLAG_NONBLOCK`.
+
+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 trans-dimensional mutation of the program's author.
+
+### 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 value of _size_ is too large.
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol for socket _s_ does not support sending.
+`NNG_ESTATE`:: The socket _s_ cannot send data in this state.
+`NNG_ETIMEDOUT`:: The operation timed out.
+
+### See Also
+
+xref:../util/nng_alloc.adoc[nng_alloc],
+xref:../util/nng_free.adoc[nng_free],
+xref:nng_recv.adoc[nng_recv],
+xref:nng_sendmsg.adoc[nng_sendmsg]