coap.h

Go to the documentation of this file.

/*
 *  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.
 */

#ifndef OPENTHREAD_COAP_H_
#define OPENTHREAD_COAP_H_

#include <stdint.h>

#include <openthread/message.h>
#include <openthread/types.h>

#ifdef __cplusplus
extern "C" {
#endif

#define OT_DEFAULT_COAP_PORT  5683  


typedef enum otCoapType
{
    OT_COAP_TYPE_CONFIRMABLE     = 0x00,  
    OT_COAP_TYPE_NON_CONFIRMABLE = 0x10,  
    OT_COAP_TYPE_ACKNOWLEDGMENT  = 0x20,  
    OT_COAP_TYPE_RESET           = 0x30,  
} otCoapType;

#define OT_COAP_CODE(c, d) ((((c) & 0x7) << 5) | ((d) & 0x1f))

typedef enum otCoapCode
{
    OT_COAP_CODE_EMPTY               = OT_COAP_CODE(0, 0),  
    OT_COAP_CODE_GET                 = OT_COAP_CODE(0, 1),  
    OT_COAP_CODE_POST                = OT_COAP_CODE(0, 2),  
    OT_COAP_CODE_PUT                 = OT_COAP_CODE(0, 3),  
    OT_COAP_CODE_DELETE              = OT_COAP_CODE(0, 4),  

    OT_COAP_CODE_RESPONSE_MIN        = OT_COAP_CODE(2, 0),  
    OT_COAP_CODE_CREATED             = OT_COAP_CODE(2, 1),  
    OT_COAP_CODE_DELETED             = OT_COAP_CODE(2, 2),  
    OT_COAP_CODE_VALID               = OT_COAP_CODE(2, 3),  
    OT_COAP_CODE_CHANGED             = OT_COAP_CODE(2, 4),  
    OT_COAP_CODE_CONTENT             = OT_COAP_CODE(2, 5),  

    OT_COAP_CODE_BAD_REQUEST         = OT_COAP_CODE(4, 0),  
    OT_COAP_CODE_UNAUTHORIZED        = OT_COAP_CODE(4, 1),  
    OT_COAP_CODE_BAD_OPTION          = OT_COAP_CODE(4, 2),  
    OT_COAP_CODE_FORBIDDEN           = OT_COAP_CODE(4, 3),  
    OT_COAP_CODE_NOT_FOUND           = OT_COAP_CODE(4, 4),  
    OT_COAP_CODE_METHOD_NOT_ALLOWED  = OT_COAP_CODE(4, 5),  
    OT_COAP_CODE_NOT_ACCEPTABLE      = OT_COAP_CODE(4, 6),  
    OT_COAP_CODE_PRECONDITION_FAILED = OT_COAP_CODE(4, 12), 
    OT_COAP_CODE_REQUEST_TOO_LARGE   = OT_COAP_CODE(4, 13), 
    OT_COAP_CODE_UNSUPPORTED_FORMAT  = OT_COAP_CODE(4, 15), 

    OT_COAP_CODE_INTERNAL_ERROR      = OT_COAP_CODE(5, 0),  
    OT_COAP_CODE_NOT_IMPLEMENTED     = OT_COAP_CODE(5, 1),  
    OT_COAP_CODE_BAD_GATEWAY         = OT_COAP_CODE(5, 2),  
    OT_COAP_CODE_SERVICE_UNAVAILABLE = OT_COAP_CODE(5, 3),  
    OT_COAP_CODE_GATEWAY_TIMEOUT     = OT_COAP_CODE(5, 4),  
    OT_COAP_CODE_PROXY_NOT_SUPPORTED = OT_COAP_CODE(5, 5),  
} otCoapCode;

typedef enum otCoapOptionType
{
    OT_COAP_OPTION_IF_MATCH       = 1,    
    OT_COAP_OPTION_URI_HOST       = 3,    
    OT_COAP_OPTION_E_TAG          = 4,    
    OT_COAP_OPTION_IF_NONE_MATCH  = 5,    
    OT_COAP_OPTION_OBSERVE        = 6,    
    OT_COAP_OPTION_URI_PORT       = 7,    
    OT_COAP_OPTION_LOCATION_PATH  = 8,    
    OT_COAP_OPTION_URI_PATH       = 11,   
    OT_COAP_OPTION_CONTENT_FORMAT = 12,   
    OT_COAP_OPTION_MAX_AGE        = 14,   
    OT_COAP_OPTION_URI_QUERY      = 15,   
    OT_COAP_OPTION_ACCEPT         = 17,   
    OT_COAP_OPTION_LOCATION_QUERY = 20,   
    OT_COAP_OPTION_PROXY_URI      = 35,   
    OT_COAP_OPTION_PROXY_SCHEME   = 39,   
    OT_COAP_OPTION_SIZE1          = 60,   
} otCoapOptionType;

typedef struct otCoapOption
{
    uint16_t       mNumber;  
    uint16_t       mLength;  
    const uint8_t *mValue;   
} otCoapOption;

typedef enum otCoapOptionContentFormat
{
    OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN    = 0,    
    OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT   = 40,   
    OT_COAP_OPTION_CONTENT_FORMAT_XML           = 41,   
    OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM  = 42,   
    OT_COAP_OPTION_CONTENT_FORMAT_EXI           = 47,   
    OT_COAP_OPTION_CONTENT_FORMAT_JSON          = 50,   
} otCoapOptionContentFormat;

#define OT_COAP_HEADER_MAX_LENGTH       128  


typedef struct otCoapHeader
{
    union
    {
        struct
        {
            uint8_t mVersionTypeToken;              
            uint8_t mCode;                          
            uint16_t mMessageId;                    
        } mFields;                                  
        uint8_t mBytes[OT_COAP_HEADER_MAX_LENGTH];  
    } mHeader;                                      
    uint8_t mHeaderLength;                          
    uint16_t mOptionLast;                           
    uint16_t mFirstOptionOffset;                    
    uint16_t mNextOptionOffset;                     
    otCoapOption mOption;                           
} otCoapHeader;

typedef void (*otCoapResponseHandler)(void *aContext, otCoapHeader *aHeader, otMessage *aMessage,
                                      const otMessageInfo *aMessageInfo, otError aResult);

typedef void (*otCoapRequestHandler)(void *aContext, otCoapHeader *aHeader, otMessage *aMessage,
                                     const otMessageInfo *aMessageInfo);

typedef struct otCoapResource
{
    const char *mUriPath;           
    otCoapRequestHandler mHandler;  
    void *mContext;                 
    struct otCoapResource *mNext;   
} otCoapResource;

void otCoapHeaderInit(otCoapHeader *aHeader, otCoapType aType, otCoapCode aCode);

void otCoapHeaderSetToken(otCoapHeader *aHeader, const uint8_t *aToken, uint8_t aTokenLength);

void otCoapHeaderGenerateToken(otCoapHeader *aHeader, uint8_t aTokenLength);

otError otCoapHeaderAppendContentFormatOption(otCoapHeader *aHeader, otCoapOptionContentFormat aContentFormat);

otError otCoapHeaderAppendOption(otCoapHeader *aHeader, const otCoapOption *aOption);

otError otCoapHeaderAppendUintOption(otCoapHeader *aHeader, uint16_t aNumber, uint32_t aValue);

otError otCoapHeaderAppendObserveOption(otCoapHeader *aHeader, uint32_t aObserve);

otError otCoapHeaderAppendUriPathOptions(otCoapHeader *aHeader, const char *aUriPath);

otError otCoapHeaderAppendMaxAgeOption(otCoapHeader *aHeader, uint32_t aMaxAge);

otError otCoapHeaderAppendUriQueryOption(otCoapHeader *aHeader, const char *aUriQuery);

void otCoapHeaderSetPayloadMarker(otCoapHeader *aHeader);

void otCoapHeaderSetMessageId(otCoapHeader *aHeader, uint16_t aMessageId);

otCoapType otCoapHeaderGetType(const otCoapHeader *aHeader);

otCoapCode otCoapHeaderGetCode(const otCoapHeader *aHeader);

uint16_t otCoapHeaderGetMessageId(const otCoapHeader *aHeader);

uint8_t otCoapHeaderGetTokenLength(const otCoapHeader *aHeader);

const uint8_t *otCoapHeaderGetToken(const otCoapHeader *aHeader);

const otCoapOption *otCoapHeaderGetFirstOption(otCoapHeader *aHeader);

const otCoapOption *otCoapHeaderGetNextOption(otCoapHeader *aHeader);

otMessage *otCoapNewMessage(otInstance *aInstance, const otCoapHeader *aHeader);

otError otCoapSendRequest(otInstance *aInstance, otMessage *aMessage, const otMessageInfo *aMessageInfo,
                          otCoapResponseHandler aHandler, void *aContext);

otError otCoapStart(otInstance *aInstance, uint16_t aPort);

otError otCoapStop(otInstance *aInstance);

otError otCoapAddResource(otInstance *aInstance, otCoapResource *aResource);

void otCoapRemoveResource(otInstance *aInstance, otCoapResource *aResource);

void otCoapSetDefaultHandler(otInstance *aInstance, otCoapRequestHandler aHandler, void *aContext);

otError otCoapSendResponse(otInstance *aInstance, otMessage *aMessage, const otMessageInfo *aMessageInfo);

#ifdef __cplusplus
}  // extern "C"
#endif

#endif /* OPENTHREAD_COAP_H_ */