Synchronous sock based messaging with nanocoap. More...
Synchronous sock based messaging with nanocoap.
nanocoap sock uses the nanocoap CoAP library to provide a synchronous interface to RIOT's sock networking API to read and write CoAP messages. For a server, nanocoap sock accepts a list of resource paths with callbacks for writing the response. For a client, nanocoap sock provides a function to send a request and waits for the server response. nanocoap sock uses nanocoap's Buffer API to write message options.
See the nanocoap_server example, which is built on the nanocoap_server()
function. A server must define CoAP resources for which it responds.
Each coap_resource_t is added to the XFA with NANOCOAP_RESOURCE(name) followed by the declaration of the CoAP resource, e.g.:
nanocoap itself provides the COAP_WELL_KNOWN_CORE_DEFAULT_HANDLER entry for /.well-known/core
.
To use the CoAP resource XFA, enable the nanocoap_resources
module.
For each resource, you must implement a coap_handler_t handler function. nanocoap provides functions to help implement the handler. If the handler is called via nanocoap_server(), the response buffer provided to the handler reuses the buffer for the request. So, your handler must read the request thoroughly before writing the response.
To read the request, use the functions in the Header and Options Read sections of the nanocoap documentation. If the pkt payload_len attribute is a positive value, start to read it at the payload pointer attribute.
If a response does not require specific CoAP options, use coap_reply_simple(). If there is a payload, it writes a Content-Format option with the provided value.
For a response with additional CoAP options, start by calling coap_build_reply(). Then use the Buffer API to write the rest of the response. See the instructions in the section Write Options and Payload below.
Follow the instructions in the section Write Options and Payload below.
To send the message and await the response, see nanocoap_sock_request() as well as nanocoap_sock_get(), which additionally copies the response payload to a user supplied buffer. Finally, read the response as described above in the server Handler functions section for reading a request.
For both server responses and client requests, CoAP uses an Option mechanism to encode message metadata that is not required for each message. For example, the resource URI path is required only for a request, and is encoded as the Uri-Path option.
nanocoap sock uses the nanocoap Buffer API for options. The caller must provide the last option number written as well as the buffer position. The caller is primarily responsible for tracking and managing the space remaining in the buffer.
Before starting, ensure the CoAP header has been initialized with coap_build_hdr(). For a response, coap_build_reply() includes a call to coap_build_hdr(). Use the returned length to track the next position in the buffer to write and remaining length.
Next, use the functions in the Options Write Buffer API section of nanocoap to write each option. These functions require the position in the buffer to start writing, and return the number of bytes written. Options must be written in order by option number (see "CoAP option numbers" in CoAP defines).
If there is a payload, append a payload marker (0xFF). Then write the payload to within the maximum length remaining in the buffer.
Block-wise is a CoAP extension (RFC 7959) to divide a large payload across multiple physical packets. This section describes how to write a block-wise payload for a response, and is known as Block2. (Block1 is for a block-wise payload in a request.) See _riot_board_handler() in the nanocoap_server example for an example handler implementation.
Start with coap_block2_init() to read the client request and initialize a coap_slicer_t struct with the size and location for this slice of the overall payload. Then write the block2 option in the response with coap_opt_put_block2(). The option includes an indicator ("more") that a slice completes the overall payload transfer. You may not know the value for more at this point, but you must initialize the space in the packet for the option before writing the payload. The option is rewritten later.
Next, use the coap_blockwise_put_xxx() functions to write the payload content. These functions use the coap_block_slicer_t to enable or disable actually writing the content, depending on the current position within the overall payload transfer.
Finally, use the convenience function coap_block2_build_reply(), which finalizes the packet and calls coap_block2_finish() internally to update the block2 option.
Files | |
file | fs.h |
nanoCoAP virtual file system | |
file | link_format.h |
NanoCoAP Link Format helper functions. | |
file | nanocoap_sock.h |
nanocoap high-level API | |
file | nanocoap_vfs.h |
VFS NanoCoAP helper functions. | |
Data Structures | |
struct | nanocoap_sock_t |
NanoCoAP socket struct. More... | |
struct | coap_block_request_t |
Blockwise request helper struct. More... | |
struct | nanocoap_server_response_ctx_t |
Context from CoAP request for separate response. More... | |
Macros | |
#define | CONFIG_NANOCOAP_SOCK_DTLS_TAG (0xc0ab) |
Credman tag used for NanoCoAP Tag together with the credential type (PSK) needs to be unique. | |
#define | CONFIG_NANOCOAP_SERVER_BUF_SIZE |
CoAP server work buf size Used both for RX and TX, needs to hold payload block + header. | |
#define | CONFIG_NANOCOAP_SERVER_STACK_SIZE THREAD_STACKSIZE_DEFAULT |
CoAP server thread stack size. | |
#define | CONFIG_NANOCOAP_SOCK_BLOCK_TOKEN (0) |
Include a random token with block-wise transfers. | |
Enumerations | |
enum | nanocoap_socket_type_t { COAP_SOCKET_TYPE_UDP , COAP_SOCKET_TYPE_DTLS } |
NanoCoAP socket types. More... | |
Functions | |
void | nanocoap_server_prepare_separate (nanocoap_server_response_ctx_t *ctx, coap_pkt_t *pkt, const coap_request_ctx_t *req) |
Prepare the context for a separate response. | |
int | nanocoap_server_send_separate (const nanocoap_server_response_ctx_t *ctx, unsigned code, unsigned type, const void *payload, size_t len) |
Send a separate response to a CoAP request. | |
static uint16_t | nanocoap_sock_next_msg_id (nanocoap_sock_t *sock) |
Get next consecutive message ID for use when building a new CoAP request. | |
int | nanocoap_server (sock_udp_ep_t *local, uint8_t *buf, size_t bufsize) |
Start a nanocoap server instance. | |
kernel_pid_t | nanocoap_server_start (const sock_udp_ep_t *local) |
Create and start the nanoCoAP server thread. | |
static int | nanocoap_sock_connect (nanocoap_sock_t *sock, const sock_udp_ep_t *local, const sock_udp_ep_t *remote) |
Create a CoAP client socket. | |
int | nanocoap_sock_dtls_connect (nanocoap_sock_t *sock, sock_udp_ep_t *local, const sock_udp_ep_t *remote, credman_tag_t tag) |
Create a DTLS secured CoAP client socket. | |
int | nanocoap_sock_url_connect (const char *url, nanocoap_sock_t *sock) |
Create a CoAP client socket by URL. | |
static void | nanocoap_sock_close (nanocoap_sock_t *sock) |
Close a CoAP client socket. | |
ssize_t | nanocoap_sock_get (nanocoap_sock_t *sock, const char *path, void *buf, size_t len) |
Simple synchronous CoAP (confirmable) GET. | |
ssize_t | nanocoap_sock_get_non (nanocoap_sock_t *sock, const char *path, void *response, size_t len_max) |
Simple non-confirmable GET. | |
ssize_t | nanocoap_sock_put (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) PUT. | |
ssize_t | nanocoap_sock_put_non (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple non-confirmable PUT. | |
ssize_t | nanocoap_sock_put_url (const char *url, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) PUT to URL. | |
ssize_t | nanocoap_sock_post (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) POST. | |
ssize_t | nanocoap_sock_post_non (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple non-confirmable POST. | |
ssize_t | nanocoap_sock_post_url (const char *url, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) POST to URL. | |
ssize_t | nanocoap_sock_fetch (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) FETCH (RFC 8132) | |
ssize_t | nanocoap_sock_fetch_non (nanocoap_sock_t *sock, const char *path, const void *request, size_t len, void *response, size_t len_max) |
Simple non-confirmable FETCH (RFC 8132) | |
ssize_t | nanocoap_sock_fetch_url (const char *url, const void *request, size_t len, void *response, size_t len_max) |
Simple synchronous CoAP (confirmable) FETCH to URL (RFC 8132) | |
ssize_t | nanocoap_sock_delete (nanocoap_sock_t *sock, const char *path) |
Simple synchronous CoAP (confirmable) DELETE. | |
ssize_t | nanocoap_sock_delete_url (const char *url) |
Simple synchronous CoAP (confirmable) DELETE for URL. | |
int | nanocoap_sock_get_blockwise (nanocoap_sock_t *sock, const char *path, coap_blksize_t blksize, coap_blockwise_cb_t callback, void *arg) |
Performs a blockwise coap get request on a socket. | |
int | nanocoap_sock_get_slice (nanocoap_sock_t *sock, const char *path, coap_blksize_t blksize, size_t offset, void *dst, size_t len) |
Performs a blockwise coap get request to the specified url, store the response in a buffer. | |
int | nanocoap_get_blockwise_url (const char *url, coap_blksize_t blksize, coap_blockwise_cb_t callback, void *arg) |
Performs a blockwise coap get request to the specified url. | |
ssize_t | nanocoap_get_blockwise_url_to_buf (const char *url, coap_blksize_t blksize, void *buf, size_t len) |
Performs a blockwise coap get request to the specified url, store the response in a buffer. | |
ssize_t | nanocoap_get_blockwise_to_buf (nanocoap_sock_t *sock, const char *path, coap_blksize_t blksize, void *buf, size_t len) |
Performs a blockwise CoAP GET request, store the response in a buffer. | |
ssize_t | nanocoap_sock_request (nanocoap_sock_t *sock, coap_pkt_t *pkt, size_t len) |
Simple synchronous CoAP request. | |
ssize_t | nanocoap_sock_request_cb (nanocoap_sock_t *sock, coap_pkt_t *pkt, coap_request_cb_t cb, void *arg) |
Simple synchronous CoAP request with callback. | |
ssize_t | nanocoap_request (coap_pkt_t *pkt, const sock_udp_ep_t *local, const sock_udp_ep_t *remote, size_t len) |
Simple synchronous CoAP request. | |
static int | nanocoap_block_request_connect_url (coap_block_request_t *ctx, nanocoap_sock_t *sock, const char *url, coap_method_t method, coap_blksize_t blksize) |
Initialize block request context by URL and connect a socket. | |
int | nanocoap_sock_block_request (coap_block_request_t *ctx, const void *data, size_t len, bool more, coap_request_cb_t cb, void *arg) |
Do a block-wise request, send a single block. | |
#define CONFIG_NANOCOAP_SERVER_BUF_SIZE |
CoAP server work buf size Used both for RX and TX, needs to hold payload block + header.
Definition at line 167 of file nanocoap_sock.h.
#define CONFIG_NANOCOAP_SERVER_STACK_SIZE THREAD_STACKSIZE_DEFAULT |
CoAP server thread stack size.
Definition at line 175 of file nanocoap_sock.h.
#define CONFIG_NANOCOAP_SOCK_BLOCK_TOKEN (0) |
Include a random token with block-wise transfers.
This is a workaround for buggy CoPA implementations (e.g. go-coap) that expect to identify block-wise transfers based on the token.
See https://github.com/plgd-dev/go-coap/issues/512
Definition at line 187 of file nanocoap_sock.h.
#define CONFIG_NANOCOAP_SOCK_DTLS_TAG (0xc0ab) |
Credman tag used for NanoCoAP Tag together with the credential type (PSK) needs to be unique.
Definition at line 159 of file nanocoap_sock.h.
NanoCoAP socket types.
Enumerator | |
---|---|
COAP_SOCKET_TYPE_UDP | transport is plain UDP |
COAP_SOCKET_TYPE_DTLS | transport is DTLS |
Definition at line 193 of file nanocoap_sock.h.
|
inlinestatic |
Initialize block request context by URL and connect a socket.
[out] | ctx | The block request context to initialize |
[out] | sock | Socket to initialize and use for the request |
[in] | url | The request URL |
[in] | method | Request method (COAP_METHOD_{GET|PUT|POST|FETCH} ) |
[in] | blksize | Request blocksize exponent |
0 | Success |
<0 | Error (see nanocoap_sock_url_connect for details) |
Definition at line 760 of file nanocoap_sock.h.
ssize_t nanocoap_get_blockwise_to_buf | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
coap_blksize_t | blksize, | ||
void * | buf, | ||
size_t | len | ||
) |
Performs a blockwise CoAP GET request, store the response in a buffer.
This function will fetch the content of the specified resource path via block-wise-transfer. The blocks will be re-assembled into buf
[in] | sock | socket to use for the request |
[in] | path | pointer to source path |
[in] | blksize | sender suggested SZX for the COAP block request |
[in] | buf | Target buffer |
[in] | len | Target buffer length |
int nanocoap_get_blockwise_url | ( | const char * | url, |
coap_blksize_t | blksize, | ||
coap_blockwise_cb_t | callback, | ||
void * | arg | ||
) |
Performs a blockwise coap get request to the specified url.
This function will fetch the content of the specified resource path via block-wise-transfer. A coap_blockwise_cb_t will be called on each received block.
[in] | url | Absolute URL pointer to source path (i.e. not containing a fragment identifier) |
[in] | blksize | sender suggested SZX for the COAP block request |
[in] | callback | callback to be executed on each received block |
[in] | arg | optional function arguments |
ssize_t nanocoap_get_blockwise_url_to_buf | ( | const char * | url, |
coap_blksize_t | blksize, | ||
void * | buf, | ||
size_t | len | ||
) |
Performs a blockwise coap get request to the specified url, store the response in a buffer.
This function will fetch the content of the specified resource path via block-wise-transfer. The blocks will be re-assembled into buf
[in] | url | Absolute URL pointer to source path (i.e. not containing a fragment identifier) |
[in] | blksize | sender suggested SZX for the COAP block request |
[in] | buf | Target buffer |
[in] | len | Target buffer length |
ssize_t nanocoap_request | ( | coap_pkt_t * | pkt, |
const sock_udp_ep_t * | local, | ||
const sock_udp_ep_t * | remote, | ||
size_t | len | ||
) |
Simple synchronous CoAP request.
[in,out] | pkt | Packet struct containing the request. Is reused for the response |
[in] | local | Local UDP endpoint, may be NULL |
[in] | remote | remote UDP endpoint |
[in] | len | Total length of the buffer associated with the request |
int nanocoap_server | ( | sock_udp_ep_t * | local, |
uint8_t * | buf, | ||
size_t | bufsize | ||
) |
Start a nanocoap server instance.
This function only returns if there's an error binding to local
, or if receiving of UDP packets fails.
[in] | local | local UDP endpoint to bind to |
[in] | buf | input buffer to use |
[in] | bufsize | size of buf |
void nanocoap_server_prepare_separate | ( | nanocoap_server_response_ctx_t * | ctx, |
coap_pkt_t * | pkt, | ||
const coap_request_ctx_t * | req | ||
) |
Prepare the context for a separate response.
This function serializes the CoAP request information so that a separate response can be generated outside the CoAP handler.
The CoAP handler should then respond with an empty ACK by calling coap_build_empty_ack
[out] | ctx | Context information for separate response |
[in] | pkt | CoAP packet to which the response will be generated |
[in] | req | Context of the CoAP request |
int nanocoap_server_send_separate | ( | const nanocoap_server_response_ctx_t * | ctx, |
unsigned | code, | ||
unsigned | type, | ||
const void * | payload, | ||
size_t | len | ||
) |
Send a separate response to a CoAP request.
This sends a response to a CoAP request outside the CoAP handler
ctx
inside the CoAP handler[in] | ctx | Context information for the CoAP response |
[in] | code | CoAP response code |
[in] | type | Response type, may be COAP_TYPE_NON |
[in] | payload | Response payload |
[in] | len | Payload length |
kernel_pid_t nanocoap_server_start | ( | const sock_udp_ep_t * | local | ) |
Create and start the nanoCoAP server thread.
To automatically start the nanoCoAP server on startup, select the nanocoap_server_auto_init
module.
[in] | local | UDP endpoint to bind to |
int nanocoap_sock_block_request | ( | coap_block_request_t * | ctx, |
const void * | data, | ||
size_t | len, | ||
bool | more, | ||
coap_request_cb_t | cb, | ||
void * | arg | ||
) |
Do a block-wise request, send a single block.
This method is expected to be called in a loop until all payload blocks have been transferred.
ctx
was initialized with nanocoap_block_request_connect_url or manually.[in] | ctx | blockwise request context |
[in] | data | payload to send |
[in] | len | payload length |
[in] | more | more blocks after this one (will be set automatically if len > block size) |
[in] | cb | callback for response |
[in] | arg | callback context |
|
inlinestatic |
Close a CoAP client socket.
[in] | sock | CoAP UDP socket |
Definition at line 367 of file nanocoap_sock.h.
|
inlinestatic |
Create a CoAP client socket.
[out] | sock | CoAP UDP socket |
[in] | local | Local UDP endpoint, may be NULL |
[in] | remote | remote UDP endpoint |
Definition at line 322 of file nanocoap_sock.h.
ssize_t nanocoap_sock_delete | ( | nanocoap_sock_t * | sock, |
const char * | path | ||
) |
Simple synchronous CoAP (confirmable) DELETE.
[in] | sock | socket to use for the request |
[in] | path | remote path (with query) to delete |
ssize_t nanocoap_sock_delete_url | ( | const char * | url | ) |
Simple synchronous CoAP (confirmable) DELETE for URL.
[in] | url | URL of the resource that should be deleted |
int nanocoap_sock_dtls_connect | ( | nanocoap_sock_t * | sock, |
sock_udp_ep_t * | local, | ||
const sock_udp_ep_t * | remote, | ||
credman_tag_t | tag | ||
) |
Create a DTLS secured CoAP client socket.
[out] | sock | CoAP UDP socket |
[in] | local | Local UDP endpoint, may be NULL |
[in] | remote | remote UDP endpoint |
[in] | tag | Tag of the PSK credential to use Has to be added with credman_add |
ssize_t nanocoap_sock_fetch | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) FETCH (RFC 8132)
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_fetch_non | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple non-confirmable FETCH (RFC 8132)
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_fetch_url | ( | const char * | url, |
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) FETCH to URL (RFC 8132)
[in] | url | Absolute URL pointer to source path |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_get | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
void * | buf, | ||
size_t | len | ||
) |
Simple synchronous CoAP (confirmable) GET.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[out] | buf | buffer to write response to |
[in] | len | length of buffer |
int nanocoap_sock_get_blockwise | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
coap_blksize_t | blksize, | ||
coap_blockwise_cb_t | callback, | ||
void * | arg | ||
) |
Performs a blockwise coap get request on a socket.
This function will fetch the content of the specified resource path via block-wise-transfer. A coap_blockwise_cb_t will be called on each received block.
[in] | sock | socket to use for the request |
[in] | path | pointer to source path |
[in] | blksize | sender suggested SZX for the COAP block request |
[in] | callback | callback to be executed on each received block |
[in] | arg | optional function arguments |
ssize_t nanocoap_sock_get_non | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple non-confirmable GET.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
int nanocoap_sock_get_slice | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
coap_blksize_t | blksize, | ||
size_t | offset, | ||
void * | dst, | ||
size_t | len | ||
) |
Performs a blockwise coap get request to the specified url, store the response in a buffer.
[in] | sock | socket to use for the request |
[in] | path | Absolute URL pointer to source path |
[in] | blksize | sender suggested SZX for the COAP block request |
[in] | offset | Offset in bytes from the start of the resource |
[in] | dst | Target buffer |
[in] | len | Target buffer length |
|
inlinestatic |
Get next consecutive message ID for use when building a new CoAP request.
[in] | sock | CoAP socket on which the ID is used |
Definition at line 281 of file nanocoap_sock.h.
ssize_t nanocoap_sock_post | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) POST.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_post_non | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple non-confirmable POST.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_post_url | ( | const char * | url, |
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) POST to URL.
[in] | url | Absolute URL pointer to source path |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_put | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) PUT.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_put_non | ( | nanocoap_sock_t * | sock, |
const char * | path, | ||
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple non-confirmable PUT.
[in] | sock | socket to use for the request |
[in] | path | remote path and query |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_put_url | ( | const char * | url, |
const void * | request, | ||
size_t | len, | ||
void * | response, | ||
size_t | len_max | ||
) |
Simple synchronous CoAP (confirmable) PUT to URL.
[in] | url | Absolute URL pointer to source path |
[in] | request | buffer containing the payload |
[in] | len | length of the payload to send |
[out] | response | buffer for the response, may be NULL |
[in] | len_max | length of response |
ssize_t nanocoap_sock_request | ( | nanocoap_sock_t * | sock, |
coap_pkt_t * | pkt, | ||
size_t | len | ||
) |
Simple synchronous CoAP request.
[in] | sock | socket to use for the request |
[in,out] | pkt | Packet struct containing the request. Is reused for the response |
[in] | len | Total length of the buffer associated with the request |
ssize_t nanocoap_sock_request_cb | ( | nanocoap_sock_t * | sock, |
coap_pkt_t * | pkt, | ||
coap_request_cb_t | cb, | ||
void * | arg | ||
) |
Simple synchronous CoAP request with callback.
The response will be handled by a callback, which avoids copying the response packet out of the network stack internal buffer.
[in] | sock | socket to use for the request |
[in,out] | pkt | Packet struct containing the request. Is reused for the response |
[in] | cb | Callback executed for response packet |
[in] | arg | Optional callback argumnent |
cb
== NULL, or for a 2.xx response cb
== NULL and the response indicates a 4.xx client error cb
== NULL and the response indicates a 5.xx server error cb
for a matching response int nanocoap_sock_url_connect | ( | const char * | url, |
nanocoap_sock_t * | sock | ||
) |
Create a CoAP client socket by URL.
[in] | url | URL with server information to connect to |
[out] | sock | CoAP UDP socket |