Documentation

Documentation

Includes

coap_net.h

#include "coap_net.h"
#include "coap_net.h"

Macros

Marco COAP_ASYNC_H_

#define COAP_ASYNC_H_


      

Marco COAP_ASYNC_CONFIRM

#define COAP_ASYNC_CONFIRM  1 /**< send confirmable response */
/* Definitions for Async Status Flags These flags can be used to control the
 * behaviour of asynchronous response generation.
 */

Marco COAP_ASYNC_SEPARATE

#define COAP_ASYNC_SEPARATE 2 /**< send separate response */


      

Marco COAP_ASYNC_OBSERVED

#define COAP_ASYNC_OBSERVED 4 /**< the resource is being observed */


      

Marco COAP_ASYNC_RELEASE_DATA

#define COAP_ASYNC_RELEASE_DATA 8
/** release application data on destruction */

Functions

Func coap_remove_async

int coap_remove_async(coap_context_t *context,
                     coap_session_t *session,
                     coap_tid_t id,
                     coap_async_state_t **s);
/**
 * Removes the state object identified by @p id from @p context. The removed
 * object is returned in @p s, if found. Otherwise, @p s is undefined. This
 * function returns @c 1 if the object was removed, @c 0 otherwise. Note that
 * the storage allocated for the stored object is not released by this
 * functions. You will have to call coap_free_async() to do so.
 *
 * @param context The context where the async object is registered.
 * @param session  The session that is used for asynchronous transmissions.
 * @param id      The identifier of the asynchronous transaction.
 * @param s       Will be set to the object identified by @p id after removal.
 *
 * @return        @c 1 if object was removed and @p s updated, or @c 0 if no
 *                object was found with the given id. @p s is valid only if the
 *                return value is @c 1.
 */

Func coap_free_async

void
coap_free_async(coap_async_state_t *state);
/**
 * Releases the memory that was allocated by coap_async_state_init() for the
 * object @p s. The registered application data will be released automatically
 * if COAP_ASYNC_RELEASE_DATA is set.
 *
 * @param state The object to delete.
 */

Vars

Variable coap_async_state_t

coap_async_state_t *
coap_register_async(coap_context_t *context,
                   coap_session_t *session,
                   coap_pdu_t *request,
                   unsigned char flags,
                   void *data);
/**
 * Allocates a new coap_async_state_t object and fills its fields according to
 * the given @p request. The @p flags are used to control generation of empty
 * ACK responses to stop retransmissions and to release registered @p data when
 * the resource is deleted by coap_free_async(). This function returns a pointer
 * to the registered coap_async_t object or @c NULL on error. Note that this
 * function will return @c NULL in case that an object with the same identifier
 * is already registered.
 *
 * @param context  The context to use.
 * @param session  The session that is used for asynchronous transmissions.
 * @param request  The request that is handled asynchronously.
 * @param flags    Flags to control state management.
 * @param data     Opaque application data to register. Note that the
 *                 storage occupied by @p data is released on destruction
 *                 only if flag COAP_ASYNC_RELEASE_DATA is set.
 *
 * @return         A pointer to the registered coap_async_state_t object or @c
 *                 NULL in case of an error.
 */

Variable coap_async_state_t

coap_async_state_t *coap_find_async(coap_context_t *context, coap_session_t *session, coap_tid_t id);
/**
 * Retrieves the object identified by @p id from the list of asynchronous
 * transactions that are registered with @p context. This function returns a
 * pointer to that object or @c NULL if not found.
 *
 * @param context The context where the asynchronous objects are registered
 *                with.
 * @param session  The session that is used for asynchronous transmissions.
 * @param id      The id of the object to retrieve.
 *
 * @return        A pointer to the object identified by @p id or @c NULL if
 *                not found.
 */

Consts

Types

Typedefs

Typedef coap_async_state_t;

typedef struct coap_async_state_t {
 unsigned char flags; /**< holds the flags to control behaviour */

 /**
   * Holds the internal time when the object was registered with a
   * resource. This field will be updated whenever
   * coap_register_async() is called for a specific resource.
   */
 coap_tick_t created;

 /**
   * This field can be used to register opaque application data with the
   * asynchronous state object.
   */
 void *appdata;
 uint16_t message_id;      /**< id of last message seen */
 coap_session_t *session;        /**< transaction session */
 coap_tid_t id;                  /**< transaction id */
 struct coap_async_state_t *next; /**< internally used for linking */
 size_t tokenlen;                /**< length of the token */
 uint8_t token[8];               /**< the token to use in a response */
} coap_async_state_t;
/**
 * @defgroup coap_async Asynchronous Messaging
 * @{
 * Structure for managing asynchronous state of CoAP resources. A
 * coap_resource_t object holds a list of coap_async_state_t objects that can be
 * used to generate a separate response in case a result of an operation cannot
 * be delivered in time, or the resource has been explicitly subscribed to with
 * the option @c observe.
 */