text: /*
   *  Copyright (c) 2016, The OpenThread Authors.
   *  All rights reserved.
   *
   *  Redistribution and use in source and binary forms, with or without
   *  modification, are permitted provided that the following conditions are met:
   *  1. Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the following disclaimer.
   *  2. Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in the
   *     documentation and/or other materials provided with the distribution.
   *  3. Neither the name of the copyright holder nor the
   *     names of its contributors may be used to endorse or promote products
   *     derived from this software without specific prior written permission.
   *
   *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   *  POSSIBILITY OF SUCH DAMAGE.
   */
  
  /**
   * @file
   * @brief
   *  This file defines the top-level functions for the OpenThread CoAP implementation.
   */
  
  #ifndef OPENTHREAD_COAP_H_
  #define OPENTHREAD_COAP_H_
  
  #include <stdint.h>
  
  #include <openthread/ip6.h>
  #include <openthread/message.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * @addtogroup api-coap
   *
   * @brief
   *   This module includes functions that control CoAP communication.
   *
   *   The functions in this module are available when application-coap feature (`OPENTHREAD_ENABLE_APPLICATION_COAP`) is
   *   enabled.
   *
   * @{
   *
   */
  
  #define OT_DEFAULT_COAP_PORT 5683 ///< Default CoAP port, as specified in RFC 7252
  
  #define OT_COAP_MAX_TOKEN_LENGTH 8 ///< Max token length as specified (RFC 7252).
  
  /**
   * CoAP Type values.
   *
   */
  typedef enum otCoapType {
      OT_COAP_TYPE_CONFIRMABLE     = 0x00, ///< Confirmable
      OT_COAP_TYPE_NON_CONFIRMABLE = 0x10, ///< Non-confirmable
      OT_COAP_TYPE_ACKNOWLEDGMENT  = 0x20, ///< Acknowledgment
      OT_COAP_TYPE_RESET           = 0x30, ///< Reset
  } otCoapType;
  
  /**
   * Helper macro to define CoAP Code values.
   *
   */
  #define OT_COAP_CODE(c, d) ((((c)&0x7) << 5) | ((d)&0x1f))
  
  /**
   * CoAP Code values.
   *
   */
  typedef enum otCoapCode {
      OT_COAP_CODE_EMPTY  = OT_COAP_CODE(0, 0), ///< Empty message code
      OT_COAP_CODE_GET    = OT_COAP_CODE(0, 1), ///< Get
      OT_COAP_CODE_POST   = OT_COAP_CODE(0, 2), ///< Post
      OT_COAP_CODE_PUT    = OT_COAP_CODE(0, 3), ///< Put
      OT_COAP_CODE_DELETE = OT_COAP_CODE(0, 4), ///< Delete
  
      OT_COAP_CODE_RESPONSE_MIN = OT_COAP_CODE(2, 0), ///< 2.00
      OT_COAP_CODE_CREATED      = OT_COAP_CODE(2, 1), ///< Created
      OT_COAP_CODE_DELETED      = OT_COAP_CODE(2, 2), ///< Deleted
      OT_COAP_CODE_VALID        = OT_COAP_CODE(2, 3), ///< Valid
      OT_COAP_CODE_CHANGED      = OT_COAP_CODE(2, 4), ///< Changed
      OT_COAP_CODE_CONTENT      = OT_COAP_CODE(2, 5), ///< Content
  
      OT_COAP_CODE_BAD_REQUEST         = OT_COAP_CODE(4, 0),  ///< Bad Request
      OT_COAP_CODE_UNAUTHORIZED        = OT_COAP_CODE(4, 1),  ///< Unauthorized
      OT_COAP_CODE_BAD_OPTION          = OT_COAP_CODE(4, 2),  ///< Bad Option
      OT_COAP_CODE_FORBIDDEN           = OT_COAP_CODE(4, 3),  ///< Forbidden
      OT_COAP_CODE_NOT_FOUND           = OT_COAP_CODE(4, 4),  ///< Not Found
      OT_COAP_CODE_METHOD_NOT_ALLOWED  = OT_COAP_CODE(4, 5),  ///< Method Not Allowed
      OT_COAP_CODE_NOT_ACCEPTABLE      = OT_COAP_CODE(4, 6),  ///< Not Acceptable
      OT_COAP_CODE_PRECONDITION_FAILED = OT_COAP_CODE(4, 12), ///< Precondition Failed
      OT_COAP_CODE_REQUEST_TOO_LARGE   = OT_COAP_CODE(4, 13), ///< Request Entity Too Large
      OT_COAP_CODE_UNSUPPORTED_FORMAT  = OT_COAP_CODE(4, 15), ///< Unsupported Content-Format
  
      OT_COAP_CODE_INTERNAL_ERROR      = OT_COAP_CODE(5, 0), ///< Internal Server Error
      OT_COAP_CODE_NOT_IMPLEMENTED     = OT_COAP_CODE(5, 1), ///< Not Implemented
      OT_COAP_CODE_BAD_GATEWAY         = OT_COAP_CODE(5, 2), ///< Bad Gateway
      OT_COAP_CODE_SERVICE_UNAVAILABLE = OT_COAP_CODE(5, 3), ///< Service Unavailable
      OT_COAP_CODE_GATEWAY_TIMEOUT     = OT_COAP_CODE(5, 4), ///< Gateway Timeout
      OT_COAP_CODE_PROXY_NOT_SUPPORTED = OT_COAP_CODE(5, 5), ///< Proxying Not Supported
  } otCoapCode;
  
  /**
   * CoAP Option Numbers
   */
  typedef enum otCoapOptionType {
      OT_COAP_OPTION_IF_MATCH       = 1,  ///< If-Match
      OT_COAP_OPTION_URI_HOST       = 3,  ///< Uri-Host
      OT_COAP_OPTION_E_TAG          = 4,  ///< ETag
      OT_COAP_OPTION_IF_NONE_MATCH  = 5,  ///< If-None-Match
      OT_COAP_OPTION_OBSERVE        = 6,  ///< Observe
      OT_COAP_OPTION_URI_PORT       = 7,  ///< Uri-Port
      OT_COAP_OPTION_LOCATION_PATH  = 8,  ///< Location-Path
      OT_COAP_OPTION_URI_PATH       = 11, ///< Uri-Path
      OT_COAP_OPTION_CONTENT_FORMAT = 12, ///< Content-Format
      OT_COAP_OPTION_MAX_AGE        = 14, ///< Max-Age
      OT_COAP_OPTION_URI_QUERY      = 15, ///< Uri-Query
      OT_COAP_OPTION_ACCEPT         = 17, ///< Accept
      OT_COAP_OPTION_LOCATION_QUERY = 20, ///< Location-Query
      OT_COAP_OPTION_PROXY_URI      = 35, ///< Proxy-Uri
      OT_COAP_OPTION_PROXY_SCHEME   = 39, ///< Proxy-Scheme
      OT_COAP_OPTION_SIZE1          = 60, ///< Size1
  } otCoapOptionType;
  
  /**
   * This structure represents a CoAP option.
   *
   */
  typedef struct otCoapOption
  {
      uint16_t       mNumber; ///< Option Number
      uint16_t       mLength; ///< Option Length
      const uint8_t *mValue;  ///< A pointer to the Option Value
  } otCoapOption;
  
  /**
   * CoAP Content Format codes.  The full list is documented at
   * https://tools.ietf.org/html/rfc7252#page-92
   *
   */
  typedef enum otCoapOptionContentFormat {
      OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN   = 0,  ///< text/plain
      OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT  = 40, ///< application/link-format
      OT_COAP_OPTION_CONTENT_FORMAT_XML          = 41, ///< application/xml
      OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM = 42, ///< application/octet-stream
      OT_COAP_OPTION_CONTENT_FORMAT_EXI          = 47, ///< application/exi
      OT_COAP_OPTION_CONTENT_FORMAT_JSON         = 50, ///< application/json
      OT_COAP_OPTION_CONTENT_FORMAT_PKCS10       = 70, ///< application/pkcs10
      OT_COAP_OPTION_CONTENT_FORMAT_PKCS7        = 80, ///< application/pkcs7
      OT_COAP_OPTION_CONTENT_FORMAT_JWS          = 101 ///< application/json-web-signature
  } otCoapOptionContentFormat;
  
  #define OT_COAP_HEADER_MAX_LENGTH 512 ///< Max CoAP header length (bytes)
  
  /**
   * This structure represents a CoAP header.
   *
   */
  typedef struct otCoapHeader
  {
      union
      {
          struct
          {
              uint8_t  mVersionTypeToken;            ///< The CoAP Version, Type, and Token Length
              uint8_t  mCode;                        ///< The CoAP Code
              uint16_t mMessageId;                   ///< The CoAP Message ID
          } mFields;                                 ///< Structure representing a CoAP base header
          uint8_t mBytes[OT_COAP_HEADER_MAX_LENGTH]; ///< The raw byte encoding for the CoAP header
      } mHeader;                                     ///< The CoAP header encoding
      uint16_t     mHeaderLength;                    ///< The CoAP header length (bytes)
      uint16_t     mOptionLast;                      ///< The last CoAP Option Number value
      uint16_t     mFirstOptionOffset;               ///< The byte offset for the first CoAP Option
      uint16_t     mNextOptionOffset;                ///< The byte offset for the next CoAP Option
      otCoapOption mOption;                          ///< A structure representing the current CoAP Option
  } otCoapHeader;
  
  /**
   * This function pointer is called when a CoAP response is received or on the request timeout.
   *
   * @param[in]  aContext      A pointer to application-specific context.
   * @param[in]  aHeader       A pointer to the received CoAP header. NULL if no response was received.
   * @param[in]  aMessage      A pointer to the message buffer containing the response. NULL if no response was received.
   * @param[in]  aMessageInfo  A pointer to the message info for @p aMessage. NULL if no response was received.
   * @param[in]  aResult       A result of the CoAP transaction.
   *
   * @retval  OT_ERROR_NONE              A response was received successfully.
   * @retval  OT_ERROR_ABORT             A CoAP transaction was reseted by peer.
   * @retval  OT_ERROR_RESPONSE_TIMEOUT  No response or acknowledgment received during timeout period.
   *
   */
  typedef void (*otCoapResponseHandler)(void *               aContext,
                                        otCoapHeader *       aHeader,
                                        otMessage *          aMessage,
                                        const otMessageInfo *aMessageInfo,
                                        otError              aResult);
  
  /**
   * This function pointer is called when a CoAP request with a given Uri-Path is received.
   *
   * @param[in]  aContext      A pointer to arbitrary context information.
   * @param[in]  aHeader       A pointer to the CoAP header.
   * @param[in]  aMessage      A pointer to the message.
   * @param[in]  aMessageInfo  A pointer to the message info for @p aMessage.
   *
   */
  typedef void (*otCoapRequestHandler)(void *               aContext,
                                       otCoapHeader *       aHeader,
                                       otMessage *          aMessage,
                                       const otMessageInfo *aMessageInfo);
  
  /**
   * This structure represents a CoAP resource.
   *
   */
  typedef struct otCoapResource
  {
      const char *           mUriPath; ///< The URI Path string
      otCoapRequestHandler   mHandler; ///< The callback for handling a received request
      void *                 mContext; ///< Application-specific context
      struct otCoapResource *mNext;    ///< The next CoAP resource in the list
  } otCoapResource;
  
  /**
   * This function initializes the CoAP header.
   *
   * @param[inout] aHeader  A pointer to the CoAP header to initialize.
   * @param[in]    aType    CoAP message type.
   * @param[in]    aCode    CoAP message code.
   *
   */
  void otCoapHeaderInit(otCoapHeader *aHeader, otCoapType aType, otCoapCode aCode);
  
  /**
   * This function sets the Token value and length in a header.
   *
   * @param[inout]  aHeader       A pointer to the CoAP header.
   * @param[in]     aToken        A pointer to the Token value.
   * @param[in]     aTokenLength  The Length of @p aToken.
   *
   */
  void otCoapHeaderSetToken(otCoapHeader *aHeader, const uint8_t *aToken, uint8_t aTokenLength);
  
  /**
   * This function sets the Token length and randomizes its value.
   *
   * @param[inout]  aHeader       A pointer to the CoAP header.
   * @param[in]     aTokenLength  The Length of a Token to set.
   *
   */
  void otCoapHeaderGenerateToken(otCoapHeader *aHeader, uint8_t aTokenLength);
  
  /**
   * This function appends the Content Format CoAP option as specified in
   * https://tools.ietf.org/html/rfc7252#page-92.  This *must* be called before
   * setting otCoapHeaderSetPayloadMarker if a payload is to be included in the
   * message.
   *
   * The function is a convenience wrapper around otCoapHeaderAppendUintOption,
   * and if the desired format type code isn't listed in otCoapOptionContentFormat,
   * this base function should be used instead.
   *
   * @param[inout]  aHeader           A pointer to the CoAP header.
   * @param[in]     aContentFormat    One of the content formats listed in
   *                                  otCoapOptionContentFormat above.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendContentFormatOption(otCoapHeader *aHeader, otCoapOptionContentFormat aContentFormat);
  
  /**
   * This function appends a CoAP option in a header.
   *
   * @param[inout]  aHeader  A pointer to the CoAP header.
   * @param[in]     aOption  A pointer to the CoAP option.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendOption(otCoapHeader *aHeader, const otCoapOption *aOption);
  
  /**
   * This function appends an unsigned integer CoAP option as specified in
   * https://tools.ietf.org/html/rfc7252#section-3.2
   *
   * @param[inout]  aHeader  A pointer to the CoAP header.
   * @param[in]     aNumber  The CoAP Option number.
   * @param[in]     aValue   The CoAP Option unsigned integer value.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendUintOption(otCoapHeader *aHeader, uint16_t aNumber, uint32_t aValue);
  
  /**
   * This function appends an Observe option.
   *
   * @param[inout]  aHeader   A pointer to the CoAP header.
   * @param[in]     aObserve  Observe field value.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendObserveOption(otCoapHeader *aHeader, uint32_t aObserve);
  
  /**
   * This function appends a Uri-Path option.
   *
   * @param[inout]  aHeader   A pointer to the CoAP header.
   * @param[in]     aUriPath  A pointer to a NULL-terminated string.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendUriPathOptions(otCoapHeader *aHeader, const char *aUriPath);
  
  /**
   * This function appends a Proxy-Uri option.
   *
   * @param[inout]  aHeader   A pointer to the CoAP header.
   * @param[in]     aUriPath  A pointer to a NULL-terminated string.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendProxyUriOption(otCoapHeader *aHeader, const char *aUriPath);
  
  /**
   * This function appends a Max-Age option.
   *
   * @param[inout]  aHeader   A pointer to the CoAP header.
   * @param[in]     aMaxAge   The Max-Age value.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   *
   */
  otError otCoapHeaderAppendMaxAgeOption(otCoapHeader *aHeader, uint32_t aMaxAge);
  
  /**
   * This function appends a single Uri-Query option.
   *
   * @param[inout]  aHeader   A pointer to the CoAP header.
   * @param[in]     aUriQuery A pointer to NULL-terminated string, which should contain a single key=value pair.
   *
   * @retval OT_ERROR_NONE          Successfully appended the option.
   * @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.
   * @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.
   */
  otError otCoapHeaderAppendUriQueryOption(otCoapHeader *aHeader, const char *aUriQuery);
  
  /**
   * This function adds Payload Marker indicating beginning of the payload to the CoAP header.
   *
   * @param[inout]  aHeader  A pointer to the CoAP header.
   *
   * @retval OT_ERROR_NONE     Payload Marker successfully added.
   * @retval OT_ERROR_NO_BUFS  Header Payload Marker exceeds the buffer size.
   *
   */
  otError otCoapHeaderSetPayloadMarker(otCoapHeader *aHeader);
  
  /**
   * This function sets the Message ID value.
   *
   * @param[in]  aHeader     A pointer to the CoAP header.
   * @param[in]  aMessageId  The Message ID value.
   *
   */
  void otCoapHeaderSetMessageId(otCoapHeader *aHeader, uint16_t aMessageId);
  
  /**
   * This function returns the Type value.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns The Type value.
   *
   */
  otCoapType otCoapHeaderGetType(const otCoapHeader *aHeader);
  
  /**
   * This function returns the Code value.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns The Code value.
   *
   */
  otCoapCode otCoapHeaderGetCode(const otCoapHeader *aHeader);
  
  /**
   * This method returns the CoAP Code as human readable string.
   *
   * @param[in]  aHeader    A pointer to the CoAP header.
   *
   * @ returns The CoAP Code as string.
   *
   */
  const char *otCoapHeaderCodeToString(const otCoapHeader *aHeader);
  
  /**
   * This function returns the Message ID value.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns The Message ID value.
   *
   */
  uint16_t otCoapHeaderGetMessageId(const otCoapHeader *aHeader);
  
  /**
   * This function returns the Token length.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns The Token length.
   *
   */
  uint8_t otCoapHeaderGetTokenLength(const otCoapHeader *aHeader);
  
  /**
   * This function returns a pointer to the Token value.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns A pointer to the Token value.
   *
   */
  const uint8_t *otCoapHeaderGetToken(const otCoapHeader *aHeader);
  
  /**
   * This function returns a pointer to the first option.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns A pointer to the first option. If no option is present NULL pointer is returned.
   *
   */
  const otCoapOption *otCoapHeaderGetFirstOption(otCoapHeader *aHeader);
  
  /**
   * This function returns a pointer to the next option.
   *
   * @param[in]  aHeader  A pointer to the CoAP header.
   *
   * @returns A pointer to the next option. If no more options are present NULL pointer is returned.
   *
   */
  const otCoapOption *otCoapHeaderGetNextOption(otCoapHeader *aHeader);
  
  /**
   * This function creates a new message with a CoAP header.
   *
   * @param[in]  aInstance     A pointer to an OpenThread instance.
   * @param[in]  aHeader  A pointer to a CoAP header that is used to create the message.
   *
   * @returns A pointer to the message or NULL if failed to allocate message.
   *
   */
  otMessage *otCoapNewMessage(otInstance *aInstance, const otCoapHeader *aHeader);
  
  /**
   * This function sends a CoAP request.
   *
   * If a response for a request is expected, respective function and context information should be provided.
   * If no response is expected, these arguments should be NULL pointers.
   *
   * @param[in]  aInstance     A pointer to an OpenThread instance.
   * @param[in]  aMessage      A pointer to the message to send.
   * @param[in]  aMessageInfo  A pointer to the message info associated with @p aMessage.
   * @param[in]  aHandler      A function pointer that shall be called on response reception or timeout.
   * @param[in]  aContext      A pointer to arbitrary context information. May be NULL if not used.
   *
   * @retval OT_ERROR_NONE    Successfully sent CoAP message.
   * @retval OT_ERROR_NO_BUFS Failed to allocate retransmission data.
   *
   */
  otError otCoapSendRequest(otInstance *          aInstance,
                            otMessage *           aMessage,
                            const otMessageInfo * aMessageInfo,
                            otCoapResponseHandler aHandler,
                            void *                aContext);
  
  /**
   * This function starts the CoAP server.
   *
   * @param[in]  aInstance  A pointer to an OpenThread instance.
   * @param[in]  aPort      The local UDP port to bind to.
   *
   * @retval OT_ERROR_NONE  Successfully started the CoAP server.
   *
   */
  otError otCoapStart(otInstance *aInstance, uint16_t aPort);
  
  /**
   * This function stops the CoAP server.
   *
   * @param[in]  aInstance  A pointer to an OpenThread instance.
   *
   * @retval OT_ERROR_NONE  Successfully stopped the CoAP server.
   *
   */
  otError otCoapStop(otInstance *aInstance);
  
  /**
   * This function adds a resource to the CoAP server.
   *
   * @param[in]  aInstance  A pointer to an OpenThread instance.
   * @param[in]  aResource  A pointer to the resource.
   *
   * @retval OT_ERROR_NONE     Successfully added @p aResource.
   * @retval OT_ERROR_ALREADY  The @p aResource was already added.
   *
   */
  otError otCoapAddResource(otInstance *aInstance, otCoapResource *aResource);
  
  /**
   * This function removes a resource from the CoAP server.
   *
   * @param[in]  aInstance  A pointer to an OpenThread instance.
   * @param[in]  aResource  A pointer to the resource.
   *
   */
  void otCoapRemoveResource(otInstance *aInstance, otCoapResource *aResource);
  
  /**
   * This function sets the default handler for unhandled CoAP requests.
   *
   * @param[in]  aInstance  A pointer to an OpenThread instance.
   * @param[in]  aHandler   A function pointer that shall be called when an unhandled request arrives.
   * @param[in]  aContext   A pointer to arbitrary context information. May be NULL if not used.
   *
   */
  void otCoapSetDefaultHandler(otInstance *aInstance, otCoapRequestHandler aHandler, void *aContext);
  
  /**
   * This function sends a CoAP response from the server.
   *
   * @param[in]  aInstance     A pointer to an OpenThread instance.
   * @param[in]  aMessage      A pointer to the CoAP response to send.
   * @param[in]  aMessageInfo  A pointer to the message info associated with @p aMessage.
   *
   * @retval OT_ERROR_NONE     Successfully enqueued the CoAP response message.
   * @retval OT_ERROR_NO_BUFS  Insufficient buffers available to send the CoAP response.
   *
   */
  otError otCoapSendResponse(otInstance *aInstance, otMessage *aMessage, const otMessageInfo *aMessageInfo);
  
  /**
   * @}
   *
   */
  
  #ifdef __cplusplus
  } // extern "C"
  #endif
  
  #endif /* OPENTHREAD_COAP_H_ */
  