espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-07-30 23:57:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[coap] process CoAP header in message (#3419)

Browse Source 
This commit refines Coap::Header into Coap::Message to avoid declaring
the big Coap::Header in stack which was causing problems in low-memory
systems such as CC2538.

A UDP reserves 56 bytes by default, which will not be used before an
outbound message goes down to transport layer and after an inbound
message is delievered to CoAP agent. To get better performance, this commit
utilizes these reserved bytes of cache basic header of CoAP message
including CoAP version, code, message ID and token. These cached data
are parsed when CoAP agent receives a CoAP message and are dumped into
the correct place of a CoAP Message before sending by lower layer.

To make sure there is enough reserved bytes for an inbound message, This
commit removes headers in UDP layer before delivering a ot::Message to
handlers.
This commit is contained in:
Yakun Xu
2019-01-15 05:00:21 -08:00
committed by Jonathan Hui
parent 1f6d7c8b3b
commit 5eee323b8d
61 changed files with 1725 additions and 2132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Android.mk
+1 -1
View File
@@ -109,7 +109,7 @@ LOCAL_SRC_FILES := \
src/core/api/thread_ftd_api.cpp \
src/core/api/udp_api.cpp \
src/core/coap/coap.cpp \
src/core/coap/coap_header.cpp \
src/core/coap/coap_message.cpp \
src/core/coap/coap_secure.cpp \
src/core/common/crc16.cpp \
src/core/common/instance.cpp \
etc/visual-studio/libopenthread.vcxproj
+2 -2
View File
@@ -75,7 +75,7 @@
<ClCompile Include="..\..\src\core\api\thread_ftd_api.cpp" />
<ClCompile Include="..\..\src\core\api\udp_api.cpp" />
<ClCompile Include="..\..\src\core\coap\coap.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_header.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_message.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_secure.cpp" />
<ClCompile Include="..\..\src\core\common\crc16.cpp" />
<ClCompile Include="..\..\src\core\common\instance.cpp" />
@@ -163,7 +163,7 @@
<ItemGroup>
<ClInclude Include="..\..\include\openthread\link_raw.h" />
<ClInclude Include="..\..\src\core\coap\coap.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_header.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_message.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_secure.hpp" />
<ClInclude Include="..\..\src\core\common\code_utils.hpp" />
<ClInclude Include="..\..\src\core\common\crc16.hpp" />
etc/visual-studio/libopenthread.vcxproj.filters
+2 -2
View File
@@ -126,7 +126,7 @@
<ClCompile Include="..\..\src\core\coap\coap.cpp">
<Filter>Source Files\coap</Filter>
</ClCompile>
<ClCompile Include="..\..\src\core\coap\coap_header.cpp">
<ClCompile Include="..\..\src\core\coap\coap_message.cpp">
<Filter>Source Files\coap</Filter>
</ClCompile>
<ClCompile Include="..\..\src\core\coap\coap_secure.cpp">
@@ -380,7 +380,7 @@
<ClInclude Include="..\..\src\core\coap\coap.hpp">
<Filter>Header Files\coap</Filter>
</ClInclude>
<ClInclude Include="..\..\src\core\coap\coap_header.hpp">
<ClInclude Include="..\..\src\core\coap\coap_message.hpp">
<Filter>Header Files\coap</Filter>
</ClInclude>
<ClInclude Include="..\..\src\core\coap\coap_secure.hpp">
etc/visual-studio/libopenthread_k.vcxproj
+2 -2
View File
@@ -84,7 +84,7 @@
<ClCompile Include="..\..\src\core\api\thread_ftd_api.cpp" />
<ClCompile Include="..\..\src\core\api\udp_api.cpp" />
<ClCompile Include="..\..\src\core\coap\coap.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_header.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_message.cpp" />
<ClCompile Include="..\..\src\core\coap\coap_secure.cpp" />
<ClCompile Include="..\..\src\core\common\crc16.cpp" />
<ClCompile Include="..\..\src\core\common\instance.cpp" />
@@ -192,7 +192,7 @@
<ClInclude Include="..\..\include\openthread-windows-config.h" />
<ClInclude Include="..\..\include\openthread\udp.h" />
<ClInclude Include="..\..\src\core\coap\coap.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_header.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_message.hpp" />
<ClInclude Include="..\..\src\core\coap\coap_secure.hpp" />
<ClInclude Include="..\..\src\core\common\code_utils.hpp" />
<ClInclude Include="..\..\src\core\common\context.hpp" />
etc/visual-studio/libopenthread_k.vcxproj.filters
+2 -2
View File
@@ -123,7 +123,7 @@
<ClCompile Include="..\..\src\core\coap\coap.cpp">
<Filter>Source Files\coap</Filter>
</ClCompile>
<ClCompile Include="..\..\src\core\coap\coap_header.cpp">
<ClCompile Include="..\..\src\core\coap\coap_message.cpp">
<Filter>Source Files\coap</Filter>
</ClCompile>
<ClCompile Include="..\..\src\core\coap\coap_secure.cpp">
@@ -374,7 +374,7 @@
<ClInclude Include="..\..\src\core\coap\coap.hpp">
<Filter>Header Files\coap</Filter>
</ClInclude>
<ClInclude Include="..\..\src\core\coap\coap_header.hpp">
<ClInclude Include="..\..\src\core\coap\coap_message.hpp">
<Filter>Header Files\coap</Filter>
</ClInclude>
<ClInclude Include="..\..\src\core\coap\coap_secure.hpp">
include/openthread/coap.h
+69 -88
View File
@@ -146,9 +146,8 @@ typedef enum otCoapOptionType
*/
typedef struct otCoapOption
{
uint16_t mNumber; ///< Option Number
uint16_t mLength; ///< Option Length
const uint8_t *mValue; ///< A pointer to the Option Value
uint16_t mNumber; ///< Option Number
uint16_t mLength; ///< Option Length
} otCoapOption;
/**
@@ -294,36 +293,10 @@ typedef enum otCoapOptionContentFormat
OT_COAP_OPTION_CONTENT_FORMAT_SENSML_XML = 311
} 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.
@@ -334,7 +307,6 @@ typedef struct otCoapHeader
*
*/
typedef void (*otCoapResponseHandler)(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
@@ -343,15 +315,11 @@ typedef void (*otCoapResponseHandler)(void * aContext,
* 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);
typedef void (*otCoapRequestHandler)(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
/**
* This structure represents a CoAP resource.
@@ -368,43 +336,43 @@ typedef struct 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.
* @param[inout] aMessage A pointer to the CoAP message to initialize.
* @param[in] aType CoAP message type.
* @param[in] aCode CoAP message code.
*
*/
void otCoapHeaderInit(otCoapHeader *aHeader, otCoapType aType, otCoapCode aCode);
void otCoapMessageInit(otMessage *aMessage, 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.
* @param[inout] aMessage A pointer to the CoAP message.
* @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);
void otCoapMessageSetToken(otMessage *aMessage, 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[inout] aMessage A pointer to the CoAP message.
* @param[in] aTokenLength The Length of a Token to set.
*
*/
void otCoapHeaderGenerateToken(otCoapHeader *aHeader, uint8_t aTokenLength);
void otCoapMessageGenerateToken(otMessage *aMessage, 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
* setting otCoapMessageSetPayloadMarker if a payload is to be included in the
* message.
*
* The function is a convenience wrapper around otCoapHeaderAppendUintOption,
* The function is a convenience wrapper around otCoapMessageAppendUintOption,
* 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[inout] aMessage A pointer to the CoAP message.
* @param[in] aContentFormat One of the content formats listed in
* otCoapOptionContentFormat above.
*
@@ -413,26 +381,28 @@ void otCoapHeaderGenerateToken(otCoapHeader *aHeader, uint8_t aTokenLength);
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendContentFormatOption(otCoapHeader *aHeader, otCoapOptionContentFormat aContentFormat);
otError otCoapMessageAppendContentFormatOption(otMessage *aMessage, 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.
* @param[inout] aMessage A pointer to the CoAP message.
* @param[in] aNumber The CoAP Option number.
* @param[in] aLength The CoAP Option length.
* @param[in] aValue A pointer to the CoAP 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 otCoapHeaderAppendOption(otCoapHeader *aHeader, const otCoapOption *aOption);
otError otCoapMessageAppendOption(otMessage *aMessage, uint16_t aNumber, uint16_t aLength, const void *aValue);
/**
* 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[inout] aMessage A pointer to the CoAP message.
* @param[in] aNumber The CoAP Option number.
* @param[in] aValue The CoAP Option unsigned integer value.
*
@@ -441,12 +411,12 @@ otError otCoapHeaderAppendOption(otCoapHeader *aHeader, const otCoapOption *aOpt
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendUintOption(otCoapHeader *aHeader, uint16_t aNumber, uint32_t aValue);
otError otCoapMessageAppendUintOption(otMessage *aMessage, uint16_t aNumber, uint32_t aValue);
/**
* This function appends an Observe option.
*
* @param[inout] aHeader A pointer to the CoAP header.
* @param[inout] aMessage A pointer to the CoAP message.
* @param[in] aObserve Observe field value.
*
* @retval OT_ERROR_NONE Successfully appended the option.
@@ -454,12 +424,12 @@ otError otCoapHeaderAppendUintOption(otCoapHeader *aHeader, uint16_t aNumber, ui
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendObserveOption(otCoapHeader *aHeader, uint32_t aObserve);
otError otCoapMessageAppendObserveOption(otMessage *aMessage, uint32_t aObserve);
/**
* This function appends a Uri-Path option.
*
* @param[inout] aHeader A pointer to the CoAP header.
* @param[inout] aMessage A pointer to the CoAP message.
* @param[in] aUriPath A pointer to a NULL-terminated string.
*
* @retval OT_ERROR_NONE Successfully appended the option.
@@ -467,12 +437,12 @@ otError otCoapHeaderAppendObserveOption(otCoapHeader *aHeader, uint32_t aObserve
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendUriPathOptions(otCoapHeader *aHeader, const char *aUriPath);
otError otCoapMessageAppendUriPathOptions(otMessage *aMessage, const char *aUriPath);
/**
* This function appends a Proxy-Uri option.
*
* @param[inout] aHeader A pointer to the CoAP header.
* @param[inout] aMessage A pointer to the CoAP message.
* @param[in] aUriPath A pointer to a NULL-terminated string.
*
* @retval OT_ERROR_NONE Successfully appended the option.
@@ -480,12 +450,12 @@ otError otCoapHeaderAppendUriPathOptions(otCoapHeader *aHeader, const char *aUri
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendProxyUriOption(otCoapHeader *aHeader, const char *aUriPath);
otError otCoapMessageAppendProxyUriOption(otMessage *aMessage, const char *aUriPath);
/**
* This function appends a Max-Age option.
*
* @param[inout] aHeader A pointer to the CoAP header.
* @param[inout] aMessage A pointer to the CoAP message.
* @param[in] aMaxAge The Max-Age value.
*
* @retval OT_ERROR_NONE Successfully appended the option.
@@ -493,134 +463,145 @@ otError otCoapHeaderAppendProxyUriOption(otCoapHeader *aHeader, const char *aUri
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError otCoapHeaderAppendMaxAgeOption(otCoapHeader *aHeader, uint32_t aMaxAge);
otError otCoapMessageAppendMaxAgeOption(otMessage *aMessage, uint32_t aMaxAge);
/**
* This function appends a single Uri-Query option.
*
* @param[inout] aHeader A pointer to the CoAP header.
* @param[inout] aMessage A pointer to the CoAP message.
* @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);
otError otCoapMessageAppendUriQueryOption(otMessage *aMessage, 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.
* @param[inout] aMessage A pointer to the CoAP message.
*
* @retval OT_ERROR_NONE Payload Marker successfully added.
* @retval OT_ERROR_NO_BUFS Header Payload Marker exceeds the buffer size.
*
*/
otError otCoapHeaderSetPayloadMarker(otCoapHeader *aHeader);
otError otCoapMessageSetPayloadMarker(otMessage *aMessage);
/**
* This function sets the Message ID value.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessageId The Message ID value.
* @param[in] aMessage A pointer to the CoAP message.
* @param[in] aMessageId The Message ID value.
*
*/
void otCoapHeaderSetMessageId(otCoapHeader *aHeader, uint16_t aMessageId);
void otCoapMessageSetMessageId(otMessage *aMessage, uint16_t aMessageId);
/**
* This function returns the Type value.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns The Type value.
*
*/
otCoapType otCoapHeaderGetType(const otCoapHeader *aHeader);
otCoapType otCoapMessageGetType(const otMessage *aMessage);
/**
* This function returns the Code value.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns The Code value.
*
*/
otCoapCode otCoapHeaderGetCode(const otCoapHeader *aHeader);
otCoapCode otCoapMessageGetCode(const otMessage *aMessage);
/**
* This method returns the CoAP Code as human readable string.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @ returns The CoAP Code as string.
*
*/
const char *otCoapHeaderCodeToString(const otCoapHeader *aHeader);
const char *otCoapMessageCodeToString(const otMessage *aMessage);
/**
* This function returns the Message ID value.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns The Message ID value.
*
*/
uint16_t otCoapHeaderGetMessageId(const otCoapHeader *aHeader);
uint16_t otCoapMessageGetMessageId(const otMessage *aMessage);
/**
* This function returns the Token length.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns The Token length.
*
*/
uint8_t otCoapHeaderGetTokenLength(const otCoapHeader *aHeader);
uint8_t otCoapMessageGetTokenLength(const otMessage *aMessage);
/**
* This function returns a pointer to the Token value.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns A pointer to the Token value.
*
*/
const uint8_t *otCoapHeaderGetToken(const otCoapHeader *aHeader);
const uint8_t *otCoapMessageGetToken(const otMessage *aMessage);
/**
* This function returns a pointer to the first option.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns A pointer to the first option. If no option is present NULL pointer is returned.
*
*/
const otCoapOption *otCoapHeaderGetFirstOption(otCoapHeader *aHeader);
const otCoapOption *otCoapMessageGetFirstOption(otMessage *aMessage);
/**
* This function returns a pointer to the next option.
*
* @param[in] aHeader A pointer to the CoAP header.
* @param[in] aMessage A pointer to the CoAP message.
*
* @returns A pointer to the next option. If no more options are present NULL pointer is returned.
*
*/
const otCoapOption *otCoapHeaderGetNextOption(otCoapHeader *aHeader);
const otCoapOption *otCoapMessageGetNextOption(otMessage *aMessage);
/**
* This function creates a new message with a CoAP header.
* This function fills current option value into @p aValue.
*
* @param[in] aMessage A pointer to the CoAP message.
* @param[out] aValue A pointer to a buffer to receive the option value.
*
* @retval OT_ERROR_NONE Successfully filled value.
* @retval OT_ERROR_NOT_FOUND No current option.
*
*/
otError otCoapMessageGetOptionValue(otMessage *aMessage, void *aValue);
/**
* This function creates a new CoAP message.
*
* @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to
* OT_MESSAGE_PRIORITY_NORMAL by default.
*
* @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.
* @param[in] aSettings A pointer to the message settings or NULL to set default settings.
*
* @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.
*
*/
otMessage *otCoapNewMessage(otInstance *aInstance, const otCoapHeader *aHeader, const otMessageSettings *aSettings);
otMessage *otCoapNewMessage(otInstance *aInstance, const otMessageSettings *aSettings);
/**
* This function sends a CoAP request.
src/cli/cli.hpp
+2 -2
View File
@@ -46,12 +46,12 @@
#include "cli/cli_udp_example.hpp"
#if OPENTHREAD_ENABLE_APPLICATION_COAP
#include <coap/coap_header.hpp>
#include <coap/coap_message.hpp>
#include "cli/cli_coap.hpp"
#endif
#if OPENTHREAD_ENABLE_APPLICATION_COAP_SECURE
#include <coap/coap_header.hpp>
#include <coap/coap_message.hpp>
#include "cli/cli_coap_secure.hpp"
#endif
src/cli/cli_coap.cpp
+32 -41
View File
@@ -38,7 +38,7 @@
#include <ctype.h>
#include "cli/cli.hpp"
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
namespace ot {
namespace Cli {
@@ -115,21 +115,17 @@ exit:
return error;
}
void OTCALL Coap::HandleServerResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void OTCALL Coap::HandleServerResponse(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Coap *>(aContext)->HandleServerResponse(aHeader, aMessage, aMessageInfo);
static_cast<Coap *>(aContext)->HandleServerResponse(aMessage, aMessageInfo);
}
void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo)
void Coap::HandleServerResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
otError error = OT_ERROR_NONE;
otCoapHeader responseHeader;
otMessage * responseMessage = NULL;
otCoapCode responseCode = OT_COAP_CODE_EMPTY;
char responseContent = '0';
otError error = OT_ERROR_NONE;
otMessage *responseMessage = NULL;
otCoapCode responseCode = OT_COAP_CODE_EMPTY;
char responseContent = '0';
mInterpreter.mServer->OutputFormat(
"Received coap request from [%x:%x:%x:%x:%x:%x:%x:%x]: ", HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[0]),
@@ -138,7 +134,7 @@ void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, cons
HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[5]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[6]),
HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[7]));
switch (otCoapHeaderGetCode(aHeader))
switch (otCoapMessageGetCode(aMessage))
{
case OT_COAP_CODE_GET:
mInterpreter.mServer->OutputFormat("GET");
@@ -163,9 +159,10 @@ void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, cons
PrintPayload(aMessage);
if ((otCoapHeaderGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE) || otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
if (otCoapMessageGetType(aMessage) == OT_COAP_TYPE_CONFIRMABLE ||
otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
responseCode = OT_COAP_CODE_CONTENT;
}
@@ -174,19 +171,19 @@ void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, cons
responseCode = OT_COAP_CODE_VALID;
}
otCoapHeaderInit(&responseHeader, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);
otCoapHeaderSetMessageId(&responseHeader, otCoapHeaderGetMessageId(aHeader));
otCoapHeaderSetToken(&responseHeader, otCoapHeaderGetToken(aHeader), otCoapHeaderGetTokenLength(aHeader));
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
otCoapHeaderSetPayloadMarker(&responseHeader);
}
responseMessage = otCoapNewMessage(mInterpreter.mInstance, &responseHeader, NULL);
responseMessage = otCoapNewMessage(mInterpreter.mInstance, NULL);
VerifyOrExit(responseMessage != NULL, error = OT_ERROR_NO_BUFS);
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
otCoapMessageInit(responseMessage, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);
otCoapMessageSetMessageId(responseMessage, otCoapMessageGetMessageId(aMessage));
otCoapMessageSetToken(responseMessage, otCoapMessageGetToken(aMessage), otCoapMessageGetTokenLength(aMessage));
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
otCoapMessageSetPayloadMarker(responseMessage);
}
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
SuccessOrExit(error = otMessageAppend(responseMessage, &responseContent, sizeof(responseContent)));
}
@@ -216,7 +213,6 @@ otError Coap::ProcessRequest(int argc, char *argv[])
otError error = OT_ERROR_NONE;
otMessage * message = NULL;
otMessageInfo messageInfo;
otCoapHeader header;
uint16_t payloadLength = 0;
// Default parameters
@@ -278,9 +274,12 @@ otError Coap::ProcessRequest(int argc, char *argv[])
}
}
otCoapHeaderInit(&header, coapType, coapCode);
otCoapHeaderGenerateToken(&header, ot::Coap::Header::kDefaultTokenLength);
SuccessOrExit(error = otCoapHeaderAppendUriPathOptions(&header, coapUri));
message = otCoapNewMessage(mInterpreter.mInstance, NULL);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
otCoapMessageInit(message, coapType, coapCode);
otCoapMessageGenerateToken(message, ot::Coap::Message::kDefaultTokenLength);
SuccessOrExit(error = otCoapMessageAppendUriPathOptions(message, coapUri));
if (argc > 4)
{
@@ -288,13 +287,10 @@ otError Coap::ProcessRequest(int argc, char *argv[])
if (payloadLength > 0)
{
otCoapHeaderSetPayloadMarker(&header);
otCoapMessageSetPayloadMarker(message);
}
}
message = otCoapNewMessage(mInterpreter.mInstance, &header, NULL);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
// Embed content into message if given
if (payloadLength > 0)
{
@@ -328,20 +324,15 @@ exit:
}
void OTCALL Coap::HandleClientResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError)
{
static_cast<Coap *>(aContext)->HandleClientResponse(aHeader, aMessage, aMessageInfo, aError);
static_cast<Coap *>(aContext)->HandleClientResponse(aMessage, aMessageInfo, aError);
}
void Coap::HandleClientResponse(otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError)
void Coap::HandleClientResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo, otError aError)
{
OT_UNUSED_VARIABLE(aHeader);
OT_UNUSED_VARIABLE(aMessageInfo);
if (aError != OT_ERROR_NONE)
src/cli/cli_coap.hpp
+4 -11
View File
@@ -38,7 +38,7 @@
#if OPENTHREAD_ENABLE_APPLICATION_COAP
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
namespace ot {
namespace Cli {
@@ -80,21 +80,14 @@ private:
otError ProcessRequest(int argc, char *argv[]);
static void OTCALL HandleServerResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void OTCALL HandleServerResponse(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleServerResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void OTCALL HandleClientResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError);
void HandleClientResponse(otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError);
void HandleClientResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo, otError aError);
otCoapResource mResource;
char mUriPath[kMaxUriLength];
src/cli/cli_coap_secure.cpp
+46 -55
View File
@@ -57,13 +57,13 @@ CoapSecure::CoapSecure(Interpreter &aInterpreter)
memset(&mPskId, 0, sizeof(mPskId));
}
void CoapSecure::PrintHeaderInfos(otCoapHeader *aHeader) const
void CoapSecure::PrintHeaderInfos(otMessage *aMessage) const
{
otCoapCode mCoapCode;
otCoapType mCoapType;
mCoapCode = otCoapHeaderGetCode(aHeader);
mCoapType = otCoapHeaderGetType(aHeader);
mCoapCode = otCoapMessageGetCode(aMessage);
mCoapType = otCoapMessageGetType(aMessage);
mInterpreter.mServer->OutputFormat("\r\n CoapSecure RX Header Information:"
"\r\n Type %d => ",
@@ -87,7 +87,7 @@ void CoapSecure::PrintHeaderInfos(otCoapHeader *aHeader) const
break;
}
mInterpreter.mServer->OutputFormat("\r\n Code %d => %s\r\n", static_cast<uint16_t>(mCoapCode),
static_cast<const char *>(otCoapHeaderCodeToString(aHeader)));
static_cast<const char *>(otCoapMessageCodeToString(aMessage)));
}
void CoapSecure::PrintPayload(otMessage *aMessage) const
@@ -348,21 +348,17 @@ void CoapSecure::HandleClientConnect(bool aConnected)
}
}
void OTCALL CoapSecure::HandleServerResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void OTCALL CoapSecure::HandleServerResponse(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<CoapSecure *>(aContext)->HandleServerResponse(aHeader, aMessage, aMessageInfo);
static_cast<CoapSecure *>(aContext)->HandleServerResponse(aMessage, aMessageInfo);
}
void CoapSecure::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo)
void CoapSecure::HandleServerResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
otError error = OT_ERROR_NONE;
otCoapHeader responseHeader;
otMessage * responseMessage = NULL;
otCoapCode responseCode = OT_COAP_CODE_EMPTY;
char responseContent[] = "helloWorld";
otError error = OT_ERROR_NONE;
otMessage *responseMessage = NULL;
otCoapCode responseCode = OT_COAP_CODE_EMPTY;
char responseContent[] = "helloWorld";
mInterpreter.mServer->OutputFormat(
"Received coap secure request from [%x:%x:%x:%x:%x:%x:%x:%x]: ",
@@ -371,7 +367,7 @@ void CoapSecure::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage
HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[4]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[5]),
HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[6]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[7]));
switch (otCoapHeaderGetCode(aHeader))
switch (otCoapMessageGetCode(aMessage))
{
case OT_COAP_CODE_GET:
mInterpreter.mServer->OutputFormat("GET");
@@ -396,9 +392,10 @@ void CoapSecure::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage
PrintPayload(aMessage);
if ((otCoapHeaderGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE) || otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
if ((otCoapMessageGetType(aMessage) == OT_COAP_TYPE_CONFIRMABLE) ||
(otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET))
{
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
responseCode = OT_COAP_CODE_CONTENT;
}
@@ -407,19 +404,19 @@ void CoapSecure::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage
responseCode = OT_COAP_CODE_VALID;
}
otCoapHeaderInit(&responseHeader, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);
otCoapHeaderSetMessageId(&responseHeader, otCoapHeaderGetMessageId(aHeader));
otCoapHeaderSetToken(&responseHeader, otCoapHeaderGetToken(aHeader), otCoapHeaderGetTokenLength(aHeader));
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
otCoapHeaderSetPayloadMarker(&responseHeader);
}
responseMessage = otCoapNewMessage(mInterpreter.mInstance, &responseHeader, NULL);
responseMessage = otCoapNewMessage(mInterpreter.mInstance, NULL);
VerifyOrExit(responseMessage != NULL, error = OT_ERROR_NO_BUFS);
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
otCoapMessageInit(responseMessage, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);
otCoapMessageSetMessageId(responseMessage, otCoapMessageGetMessageId(aMessage));
otCoapMessageSetToken(responseMessage, otCoapMessageGetToken(aMessage), otCoapMessageGetTokenLength(aMessage));
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
otCoapMessageSetPayloadMarker(responseMessage);
}
if (otCoapMessageGetCode(aMessage) == OT_COAP_CODE_GET)
{
SuccessOrExit(error = otMessageAppend(responseMessage, &responseContent, sizeof(responseContent)));
}
@@ -446,7 +443,6 @@ otError CoapSecure::ProcessRequest(int argc, char *argv[])
otError error = OT_ERROR_NONE;
otMessage * message = NULL;
otMessageInfo messageInfo;
otCoapHeader header;
uint16_t payloadLength = 0;
uint8_t indexShifter = 0;
@@ -516,9 +512,12 @@ otError CoapSecure::ProcessRequest(int argc, char *argv[])
}
}
otCoapHeaderInit(&header, coapType, coapCode);
otCoapHeaderGenerateToken(&header, ot::Coap::Header::kDefaultTokenLength);
SuccessOrExit(error = otCoapHeaderAppendUriPathOptions(&header, coapUri));
message = otCoapNewMessage(mInterpreter.mInstance, NULL);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
otCoapMessageInit(message, coapType, coapCode);
otCoapMessageGenerateToken(message, ot::Coap::Message::kDefaultTokenLength);
SuccessOrExit(error = otCoapMessageAppendUriPathOptions(message, coapUri));
if (argc > (4 - indexShifter))
{
@@ -526,13 +525,10 @@ otError CoapSecure::ProcessRequest(int argc, char *argv[])
if (payloadLength > 0)
{
otCoapHeaderSetPayloadMarker(&header);
otCoapMessageSetPayloadMarker(message);
}
}
message = otCoapNewMessage(mInterpreter.mInstance, &header, NULL);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
// add payload
if (payloadLength > 0)
{
@@ -566,20 +562,15 @@ exit:
}
void OTCALL CoapSecure::HandleClientResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError)
{
static_cast<CoapSecure *>(aContext)->HandleClientResponse(aHeader, aMessage, aMessageInfo, aError);
static_cast<CoapSecure *>(aContext)->HandleClientResponse(aMessage, aMessageInfo, aError);
}
void CoapSecure::HandleClientResponse(otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError)
void CoapSecure::HandleClientResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo, otError aError)
{
OT_UNUSED_VARIABLE(aHeader);
OT_UNUSED_VARIABLE(aMessageInfo);
if (aError != OT_ERROR_NONE)
@@ -590,35 +581,35 @@ void CoapSecure::HandleClientResponse(otCoapHeader * aHeader,
else
{
mInterpreter.mServer->OutputFormat("Received coap secure response");
PrintHeaderInfos(aHeader);
PrintHeaderInfos(aMessage);
PrintPayload(aMessage);
}
}
#if CLI_COAP_SECURE_USE_COAP_DEFAULT_HANDLER
void OTCALL CoapSecure::DefaultHandle(void * aContext,
otCoapHeader * aHeader,
otCoapMessage * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
static_cast<CoapSecure *>(aContext)->DefaultHandle(aHeader, aMessage, aMessageInfo);
}
void CoapSecure::DefaultHandle(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo)
void CoapSecure::DefaultHandle(otCoapMessage *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessage);
otError error = OT_ERROR_NONE;
otCoapHeader responseHeader;
otMessage * responseMessage;
otError error = OT_ERROR_NONE;
otCoapMessage responseHeader;
otMessage * responseMessage;
if (otCoapHeaderGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE || otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
if (otCoapMessageGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE || otCoapMessageGetCode(aHeader) == OT_COAP_CODE_GET)
{
otCoapHeaderInit(&responseHeader, OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_NOT_FOUND);
otCoapHeaderSetMessageId(&responseHeader, otCoapHeaderGetMessageId(aHeader));
otCoapHeaderSetToken(&responseHeader, otCoapHeaderGetToken(aHeader), otCoapHeaderGetTokenLength(aHeader));
otCoapMessageInit(&responseHeader, OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_NOT_FOUND);
otCoapMessageSetMessageId(&responseHeader, otCoapMessageGetMessageId(aHeader));
otCoapMessageSetToken(&responseHeader, otCoapMessageGetToken(aHeader), otCoapMessageGetTokenLength(aHeader));
responseMessage = otCoapNewMessage(mInterpreter.mInstance, &responseHeader, NULL);
responseMessage = otCoapNewMessage(mInterpreter.mInstance, NULL);
VerifyOrExit(responseMessage != NULL, error = OT_ERROR_NO_BUFS);
SuccessOrExit(error = otCoapSecureSendResponse(mInterpreter.mInstance, responseMessage, aMessageInfo));
}
src/cli/cli_coap_secure.hpp
+7 -17
View File
@@ -38,7 +38,7 @@
#if OPENTHREAD_ENABLE_APPLICATION_COAP_SECURE
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "coap/coap_secure.hpp"
/**
@@ -84,7 +84,7 @@ private:
kPskIdMaxLength = 32
};
void PrintHeaderInfos(otCoapHeader *aHeader) const;
void PrintHeaderInfos(otMessage *aMessage) const;
void PrintPayload(otMessage *aMessage) const;
@@ -92,28 +92,18 @@ private:
otError Stop(void);
static void OTCALL HandleServerResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void OTCALL HandleServerResponse(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleServerResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void OTCALL HandleClientResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError);
void HandleClientResponse(otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aError);
void HandleClientResponse(otMessage *aMessage, const otMessageInfo *aMessageInfo, otError aError);
#if CLI_COAP_SECURE_USE_COAP_DEFAULT_HANDLER
static void OTCALL DefaultHandle(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void DefaultHandle(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void OTCALL DefaultHandle(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void DefaultHandle(otMessage *aMessage, const otMessageInfo *aMessageInfo);
#endif // CLI_COAP_SECURE_USE_COAP_DEFAULT_HANDLER
static void OTCALL HandleClientConnect(bool aConnected, void *aContext);
src/core/Makefile.am
+2 -2
View File
@@ -132,7 +132,7 @@ SOURCES_COMMON = \
api/thread_ftd_api.cpp \
api/udp_api.cpp \
coap/coap.cpp \
coap/coap_header.cpp \
coap/coap_message.cpp \
coap/coap_secure.cpp \
common/crc16.cpp \
common/instance.cpp \
@@ -289,7 +289,7 @@ HEADERS_COMMON = \
openthread-core-config.h \
openthread-core-default-config.h \
coap/coap.hpp \
coap/coap_header.hpp \
coap/coap_message.hpp \
coap/coap_secure.hpp \
common/code_utils.hpp \
common/crc16.hpp \
src/core/api/coap_api.cpp
+117 -114
View File
@@ -35,137 +35,139 @@
#include <openthread/coap.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/instance.hpp"
#if OPENTHREAD_ENABLE_APPLICATION_COAP
using namespace ot;
void otCoapHeaderInit(otCoapHeader *aHeader, otCoapType aType, otCoapCode aCode)
{
Coap::Header *header = static_cast<Coap::Header *>(aHeader);
header->Init(aType, aCode);
}
void otCoapHeaderSetToken(otCoapHeader *aHeader, const uint8_t *aToken, uint8_t aTokenLength)
{
static_cast<Coap::Header *>(aHeader)->SetToken(aToken, aTokenLength);
}
void otCoapHeaderGenerateToken(otCoapHeader *aHeader, uint8_t aTokenLength)
{
static_cast<Coap::Header *>(aHeader)->SetToken(aTokenLength);
}
otError otCoapHeaderAppendContentFormatOption(otCoapHeader *aHeader, otCoapOptionContentFormat aContentFormat)
{
return static_cast<Coap::Header *>(aHeader)->AppendContentFormatOption(aContentFormat);
}
otError otCoapHeaderAppendOption(otCoapHeader *aHeader, const otCoapOption *aOption)
{
return static_cast<Coap::Header *>(aHeader)->AppendOption(*static_cast<const Coap::Header::Option *>(aOption));
}
otError otCoapHeaderAppendUintOption(otCoapHeader *aHeader, uint16_t aNumber, uint32_t aValue)
{
return static_cast<Coap::Header *>(aHeader)->AppendUintOption(aNumber, aValue);
}
otError otCoapHeaderAppendObserveOption(otCoapHeader *aHeader, uint32_t aObserve)
{
return static_cast<Coap::Header *>(aHeader)->AppendObserveOption(aObserve);
}
otError otCoapHeaderAppendUriPathOptions(otCoapHeader *aHeader, const char *aUriPath)
{
return static_cast<Coap::Header *>(aHeader)->AppendUriPathOptions(aUriPath);
}
otError otCoapHeaderAppendProxyUriOption(otCoapHeader *aHeader, const char *aUriPath)
{
return static_cast<Coap::Header *>(aHeader)->AppendProxyUriOption(aUriPath);
}
otError otCoapHeaderAppendMaxAgeOption(otCoapHeader *aHeader, uint32_t aMaxAge)
{
return static_cast<Coap::Header *>(aHeader)->AppendMaxAgeOption(aMaxAge);
}
otError otCoapHeaderAppendUriQueryOption(otCoapHeader *aHeader, const char *aUriQuery)
{
return static_cast<Coap::Header *>(aHeader)->AppendUriQueryOption(aUriQuery);
}
otError otCoapHeaderSetPayloadMarker(otCoapHeader *aHeader)
{
return static_cast<Coap::Header *>(aHeader)->SetPayloadMarker();
}
void otCoapHeaderSetMessageId(otCoapHeader *aHeader, uint16_t aMessageId)
{
return static_cast<Coap::Header *>(aHeader)->SetMessageId(aMessageId);
}
otCoapType otCoapHeaderGetType(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->GetType();
}
otCoapCode otCoapHeaderGetCode(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->GetCode();
}
const char *otCoapHeaderCodeToString(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->CodeToString();
}
uint16_t otCoapHeaderGetMessageId(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->GetMessageId();
}
uint8_t otCoapHeaderGetTokenLength(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->GetTokenLength();
}
const uint8_t *otCoapHeaderGetToken(const otCoapHeader *aHeader)
{
return static_cast<const Coap::Header *>(aHeader)->GetToken();
}
const otCoapOption *otCoapHeaderGetFirstOption(otCoapHeader *aHeader)
{
return static_cast<const otCoapOption *>(static_cast<Coap::Header *>(aHeader)->GetFirstOption());
}
const otCoapOption *otCoapHeaderGetNextOption(otCoapHeader *aHeader)
{
return static_cast<const otCoapOption *>(static_cast<Coap::Header *>(aHeader)->GetNextOption());
}
otMessage *otCoapNewMessage(otInstance *aInstance, const otCoapHeader *aHeader, const otMessageSettings *aSettings)
otMessage *otCoapNewMessage(otInstance *aInstance, const otMessageSettings *aSettings)
{
Message * message;
Instance &instance = *static_cast<Instance *>(aInstance);
VerifyOrExit(aHeader != NULL, message = NULL);
if (aSettings != NULL)
{
VerifyOrExit(aSettings->mPriority <= OT_MESSAGE_PRIORITY_HIGH, message = NULL);
}
message = instance.GetApplicationCoap().NewMessage(*(static_cast<const Coap::Header *>(aHeader)), aSettings);
message = instance.GetApplicationCoap().NewMessage(aSettings);
exit:
return message;
}
void otCoapMessageInit(otMessage *aMessage, otCoapType aType, otCoapCode aCode)
{
static_cast<Coap::Message *>(aMessage)->Init(aType, aCode);
}
void otCoapMessageSetToken(otMessage *aMessage, const uint8_t *aToken, uint8_t aTokenLength)
{
static_cast<Coap::Message *>(aMessage)->SetToken(aToken, aTokenLength);
}
void otCoapMessageGenerateToken(otMessage *aMessage, uint8_t aTokenLength)
{
static_cast<Coap::Message *>(aMessage)->SetToken(aTokenLength);
}
otError otCoapMessageAppendContentFormatOption(otMessage *aMessage, otCoapOptionContentFormat aContentFormat)
{
return static_cast<Coap::Message *>(aMessage)->AppendContentFormatOption(aContentFormat);
}
otError otCoapMessageAppendOption(otMessage *aMessage, uint16_t aNumber, uint16_t aLength, const void *aValue)
{
return static_cast<Coap::Message *>(aMessage)->AppendOption(aNumber, aLength, aValue);
}
otError otCoapMessageAppendUintOption(otMessage *aMessage, uint16_t aNumber, uint32_t aValue)
{
return static_cast<Coap::Message *>(aMessage)->AppendUintOption(aNumber, aValue);
}
otError otCoapMessageAppendObserveOption(otMessage *aMessage, uint32_t aObserve)
{
return static_cast<Coap::Message *>(aMessage)->AppendObserveOption(aObserve);
}
otError otCoapMessageAppendUriPathOptions(otMessage *aMessage, const char *aUriPath)
{
return static_cast<Coap::Message *>(aMessage)->AppendUriPathOptions(aUriPath);
}
otError otCoapMessageAppendProxyUriOption(otMessage *aMessage, const char *aUriPath)
{
return static_cast<Coap::Message *>(aMessage)->AppendProxyUriOption(aUriPath);
}
otError otCoapMessageAppendMaxAgeOption(otMessage *aMessage, uint32_t aMaxAge)
{
return static_cast<Coap::Message *>(aMessage)->AppendMaxAgeOption(aMaxAge);
}
otError otCoapMessageAppendUriQueryOption(otMessage *aMessage, const char *aUriQuery)
{
return static_cast<Coap::Message *>(aMessage)->AppendUriQueryOption(aUriQuery);
}
otError otCoapMessageSetPayloadMarker(otMessage *aMessage)
{
return static_cast<Coap::Message *>(aMessage)->SetPayloadMarker();
}
void otCoapMessageSetMessageId(otMessage *aMessage, uint16_t aMessageId)
{
return static_cast<Coap::Message *>(aMessage)->SetMessageId(aMessageId);
}
otCoapType otCoapMessageGetType(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->GetType();
}
otCoapCode otCoapMessageGetCode(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->GetCode();
}
const char *otCoapMessageCodeToString(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->CodeToString();
}
uint16_t otCoapMessageGetMessageId(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->GetMessageId();
}
uint8_t otCoapMessageGetTokenLength(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->GetTokenLength();
}
const uint8_t *otCoapMessageGetToken(const otMessage *aMessage)
{
return static_cast<const Coap::Message *>(aMessage)->GetToken();
}
const otCoapOption *otCoapMessageGetFirstOption(otMessage *aMessage)
{
return static_cast<Coap::Message *>(aMessage)->GetFirstOption();
}
const otCoapOption *otCoapMessageGetNextOption(otMessage *aMessage)
{
return static_cast<Coap::Message *>(aMessage)->GetNextOption();
}
otError otCoapMessageGetOptionValue(otMessage *aMessage, void *aValue)
{
return static_cast<Coap::Message *>(aMessage)->GetOptionValue(aValue);
}
otError otCoapSendRequest(otInstance * aInstance,
otMessage * aMessage,
const otMessageInfo * aMessageInfo,
@@ -174,8 +176,9 @@ otError otCoapSendRequest(otInstance * aInstance,
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.GetApplicationCoap().SendMessage(
*static_cast<Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo), aHandler, aContext);
return instance.GetApplicationCoap().SendMessage(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo), aHandler,
aContext);
}
otError otCoapStart(otInstance *aInstance, uint16_t aPort)
@@ -217,7 +220,7 @@ otError otCoapSendResponse(otInstance *aInstance, otMessage *aMessage, const otM
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.GetApplicationCoap().SendMessage(*static_cast<Message *>(aMessage),
return instance.GetApplicationCoap().SendMessage(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
src/core/api/coap_secure_api.cpp
+3 -3
View File
@@ -36,7 +36,7 @@
#include <openthread/coap_secure.h>
#include <openthread/ip6.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "coap/coap_secure.hpp"
#include "common/instance.hpp"
@@ -198,7 +198,7 @@ otError otCoapSecureSendRequest(otInstance * aInstance,
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.GetApplicationCoapSecure().SendMessage(*static_cast<Message *>(aMessage), aHandler, aContext);
return instance.GetApplicationCoapSecure().SendMessage(*static_cast<Coap::Message *>(aMessage), aHandler, aContext);
}
otError otCoapSecureAddResource(otInstance *aInstance, otCoapResource *aResource)
@@ -235,7 +235,7 @@ otError otCoapSecureSendResponse(otInstance *aInstance, otMessage *aMessage, con
{
Instance &instance = *static_cast<Instance *>(aInstance);
return instance.GetApplicationCoapSecure().SendMessage(*static_cast<Message *>(aMessage),
return instance.GetApplicationCoapSecure().SendMessage(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
src/core/coap/coap.cpp
+99 -140
View File
@@ -77,7 +77,7 @@ exit:
otError Coap::Stop(void)
{
Message * message = mPendingRequests.GetHead();
Message * message = static_cast<Message *>(mPendingRequests.GetHead());
Message * messageToRemove;
CoapMetadata coapMetadata;
@@ -85,10 +85,10 @@ otError Coap::Stop(void)
while (message != NULL)
{
messageToRemove = message;
message = message->GetNext();
message = static_cast<Message *>(message->GetNext());
coapMetadata.ReadFrom(*messageToRemove);
FinalizeCoapTransaction(*messageToRemove, coapMetadata, NULL, NULL, NULL, OT_ERROR_ABORT);
FinalizeCoapTransaction(*messageToRemove, coapMetadata, NULL, NULL, OT_ERROR_ABORT);
}
mResponsesQueue.DequeueAllResponses();
@@ -140,15 +140,11 @@ void Coap::SetDefaultHandler(otCoapRequestHandler aHandler, void *aContext)
mDefaultHandlerContext = aContext;
}
Message *Coap::NewMessage(const Header &aHeader, const otMessageSettings *aSettings)
Message *Coap::NewMessage(const otMessageSettings *aSettings)
{
Message *message = NULL;
// Ensure that header has minimum required length.
VerifyOrExit(aHeader.GetLength() >= Header::kMinHeaderLength);
VerifyOrExit((message = mSocket.NewMessage(aHeader.GetLength(), aSettings)) != NULL);
message->Prepend(aHeader.GetBytes(), aHeader.GetLength());
VerifyOrExit((message = static_cast<Message *>(mSocket.NewMessage(0, aSettings))) != NULL);
message->SetOffset(0);
exit:
@@ -161,41 +157,39 @@ otError Coap::SendMessage(Message & aMessage,
void * aContext)
{
otError error;
Header header;
CoapMetadata coapMetadata;
Message * storedCopy = NULL;
uint16_t copyLength = 0;
SuccessOrExit(error = header.FromMessage(aMessage, 0));
if ((header.GetType() == OT_COAP_TYPE_ACKNOWLEDGMENT || header.GetType() == OT_COAP_TYPE_RESET) &&
header.GetCode() != OT_COAP_CODE_EMPTY)
if ((aMessage.GetType() == OT_COAP_TYPE_ACKNOWLEDGMENT || aMessage.GetType() == OT_COAP_TYPE_RESET) &&
aMessage.GetCode() != OT_COAP_CODE_EMPTY)
{
mResponsesQueue.EnqueueResponse(header, aMessage, aMessageInfo);
mResponsesQueue.EnqueueResponse(aMessage, aMessageInfo);
}
// Set Message Id if it was not already set.
if (header.GetMessageId() == 0 &&
(header.GetType() == OT_COAP_TYPE_CONFIRMABLE || header.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE))
if (aMessage.GetMessageId() == 0 &&
(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE || aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE))
{
header.SetMessageId(mMessageId++);
aMessage.Write(0, Header::kMinHeaderLength, header.GetBytes());
aMessage.SetMessageId(mMessageId++);
}
if (header.IsConfirmable())
aMessage.Finish();
if (aMessage.IsConfirmable())
{
// Create a copy of entire message and enqueue it.
copyLength = aMessage.GetLength();
}
else if (header.IsNonConfirmable() && (aHandler != NULL))
else if (aMessage.IsNonConfirmable() && (aHandler != NULL))
{
// As we do not retransmit non confirmable messages, create a copy of header only, for token information.
copyLength = header.GetLength();
copyLength = aMessage.GetOptionStart();
}
if (copyLength > 0)
{
coapMetadata = CoapMetadata(header.IsConfirmable(), aMessageInfo, aHandler, aContext);
coapMetadata = CoapMetadata(aMessage.IsConfirmable(), aMessageInfo, aHandler, aContext);
VerifyOrExit((storedCopy = CopyAndEnqueueMessage(aMessage, copyLength, coapMetadata)) != NULL,
error = OT_ERROR_NO_BUFS);
}
@@ -214,21 +208,21 @@ exit:
otError Coap::Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
static_cast<Message &>(aMessage).Finish();
return mSocket.SendTo(aMessage, aMessageInfo);
}
otError Coap::SendEmptyMessage(Header::Type aType, const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError Coap::SendEmptyMessage(Message::Type aType, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
otError error = OT_ERROR_NONE;
Header responseHeader;
otError error = OT_ERROR_NONE;
Message *message = NULL;
VerifyOrExit(aRequestHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE, error = OT_ERROR_INVALID_ARGS);
VerifyOrExit(aRequest.GetType() == OT_COAP_TYPE_CONFIRMABLE, error = OT_ERROR_INVALID_ARGS);
responseHeader.Init(aType, OT_COAP_CODE_EMPTY);
responseHeader.SetMessageId(aRequestHeader.GetMessageId());
VerifyOrExit((message = NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMessage(responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(aType, OT_COAP_CODE_EMPTY);
message->SetMessageId(aRequest.GetMessageId());
SuccessOrExit(error = Send(*message, aMessageInfo));
@@ -242,27 +236,24 @@ exit:
return error;
}
otError Coap::SendHeaderResponse(Header::Code aCode, const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError Coap::SendHeaderResponse(Message::Code aCode, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
otError error = OT_ERROR_NONE;
Header responseHeader;
Header::Type requestType;
Message * message = NULL;
otError error = OT_ERROR_NONE;
Message *message = NULL;
VerifyOrExit(aRequestHeader.IsRequest(), error = OT_ERROR_INVALID_ARGS);
VerifyOrExit(aRequest.IsRequest(), error = OT_ERROR_INVALID_ARGS);
VerifyOrExit((message = NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
requestType = aRequestHeader.GetType();
switch (requestType)
switch (aRequest.GetType())
{
case OT_COAP_TYPE_CONFIRMABLE:
responseHeader.Init(OT_COAP_TYPE_ACKNOWLEDGMENT, aCode);
responseHeader.SetMessageId(aRequestHeader.GetMessageId());
message->Init(OT_COAP_TYPE_ACKNOWLEDGMENT, aCode);
message->SetMessageId(aRequest.GetMessageId());
break;
case OT_COAP_TYPE_NON_CONFIRMABLE:
responseHeader.Init(OT_COAP_TYPE_NON_CONFIRMABLE, aCode);
responseHeader.SetMessageId(mMessageId++);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, aCode);
message->SetMessageId(mMessageId++);
break;
default:
@@ -270,9 +261,7 @@ otError Coap::SendHeaderResponse(Header::Code aCode, const Header &aRequestHeade
break;
}
responseHeader.SetToken(aRequestHeader.GetToken(), aRequestHeader.GetTokenLength());
VerifyOrExit((message = NewMessage(responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetToken(aRequest.GetToken(), aRequest.GetTokenLength());
SuccessOrExit(error = SendMessage(*message, aMessageInfo));
@@ -296,13 +285,13 @@ void Coap::HandleRetransmissionTimer(void)
uint32_t now = TimerMilli::GetNow();
uint32_t nextDelta = 0xffffffff;
CoapMetadata coapMetadata;
Message * message = mPendingRequests.GetHead();
Message * message = static_cast<Message *>(mPendingRequests.GetHead());
Message * nextMessage = NULL;
Ip6::MessageInfo messageInfo;
while (message != NULL)
{
nextMessage = message->GetNext();
nextMessage = static_cast<Message *>(message->GetNext());
coapMetadata.ReadFrom(*message);
if (coapMetadata.IsLater(now))
@@ -341,7 +330,7 @@ void Coap::HandleRetransmissionTimer(void)
else
{
// No expected response or acknowledgment.
FinalizeCoapTransaction(*message, coapMetadata, NULL, NULL, NULL, OT_ERROR_RESPONSE_TIMEOUT);
FinalizeCoapTransaction(*message, coapMetadata, NULL, NULL, OT_ERROR_RESPONSE_TIMEOUT);
}
message = nextMessage;
@@ -355,7 +344,6 @@ void Coap::HandleRetransmissionTimer(void)
void Coap::FinalizeCoapTransaction(Message & aRequest,
const CoapMetadata & aCoapMetadata,
Header * aResponseHeader,
Message * aResponse,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
@@ -364,8 +352,7 @@ void Coap::FinalizeCoapTransaction(Message & aRequest,
if (aCoapMetadata.mResponseHandler != NULL)
{
aCoapMetadata.mResponseHandler(aCoapMetadata.mResponseContext, aResponseHeader, aResponse, aMessageInfo,
aResult);
aCoapMetadata.mResponseHandler(aCoapMetadata.mResponseContext, aResponse, aMessageInfo, aResult);
}
}
@@ -376,14 +363,14 @@ otError Coap::AbortTransaction(otCoapResponseHandler aHandler, void *aContext)
Message * nextMessage;
CoapMetadata coapMetadata;
for (message = mPendingRequests.GetHead(); message != NULL; message = nextMessage)
for (message = static_cast<Message *>(mPendingRequests.GetHead()); message != NULL; message = nextMessage)
{
nextMessage = message->GetNext();
nextMessage = static_cast<Message *>(message->GetNext());
coapMetadata.ReadFrom(*message);
if (coapMetadata.mResponseHandler == aHandler && coapMetadata.mResponseContext == aContext)
{
FinalizeCoapTransaction(*message, coapMetadata, NULL, NULL, NULL, OT_ERROR_ABORT);
FinalizeCoapTransaction(*message, coapMetadata, NULL, NULL, OT_ERROR_ABORT);
error = OT_ERROR_NONE;
}
}
@@ -472,12 +459,11 @@ exit:
return error;
}
Message *Coap::FindRelatedRequest(const Header & aResponseHeader,
Message *Coap::FindRelatedRequest(const Message & aResponse,
const Ip6::MessageInfo &aMessageInfo,
Header & aRequestHeader,
CoapMetadata & aCoapMetadata)
{
Message *message = mPendingRequests.GetHead();
Message *message = static_cast<Message *>(mPendingRequests.GetHead());
while (message != NULL)
{
@@ -488,15 +474,11 @@ Message *Coap::FindRelatedRequest(const Header & aResponseHeader,
aCoapMetadata.mDestinationAddress.IsAnycastRoutingLocator()) &&
(aCoapMetadata.mDestinationPort == aMessageInfo.GetPeerPort()))
{
// FromMessage can return OT_ERROR_PARSE if only partial message was stored (header only),
// but payload marker is present. Assume, that stored messages are always valid.
aRequestHeader.FromMessage(*message, sizeof(CoapMetadata));
switch (aResponseHeader.GetType())
switch (aResponse.GetType())
{
case OT_COAP_TYPE_RESET:
case OT_COAP_TYPE_ACKNOWLEDGMENT:
if (aResponseHeader.GetMessageId() == aRequestHeader.GetMessageId())
if (aResponse.GetMessageId() == message->GetMessageId())
{
ExitNow();
}
@@ -505,7 +487,7 @@ Message *Coap::FindRelatedRequest(const Header & aResponseHeader,
case OT_COAP_TYPE_CONFIRMABLE:
case OT_COAP_TYPE_NON_CONFIRMABLE:
if (aResponseHeader.IsTokenEqual(aRequestHeader))
if (aResponse.IsTokenEqual(*message))
{
ExitNow();
}
@@ -514,7 +496,7 @@ Message *Coap::FindRelatedRequest(const Header & aResponseHeader,
}
}
message = message->GetNext();
message = static_cast<Message *>(message->GetNext());
}
exit:
@@ -527,77 +509,68 @@ void Coap::HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessage
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Coap::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Coap::Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
otError error;
Header header;
Message &message = static_cast<Message &>(aMessage);
SuccessOrExit(error = header.FromMessage(aMessage, 0));
if (header.IsRequest())
if (message.ParseHeader() != OT_ERROR_NONE)
{
ProcessReceivedRequest(header, aMessage, aMessageInfo);
otLogDebgCoap("Failed to parse CoAP header");
}
else if (message.IsRequest())
{
ProcessReceivedRequest(message, aMessageInfo);
}
else
{
ProcessReceivedResponse(header, aMessage, aMessageInfo);
}
exit:
if (error)
{
otLogInfoCoapErr(error, "Receive failed");
ProcessReceivedResponse(message, aMessageInfo);
}
}
void Coap::ProcessReceivedResponse(Header &aResponseHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Coap::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Header requestHeader;
CoapMetadata coapMetadata;
Message * message = NULL;
Message * request = NULL;
otError error = OT_ERROR_NONE;
aMessage.MoveOffset(aResponseHeader.GetLength());
request = FindRelatedRequest(aMessage, aMessageInfo, coapMetadata);
message = FindRelatedRequest(aResponseHeader, aMessageInfo, requestHeader, coapMetadata);
if (message == NULL)
if (request == NULL)
{
ExitNow();
}
switch (aResponseHeader.GetType())
switch (aMessage.GetType())
{
case OT_COAP_TYPE_RESET:
if (aResponseHeader.IsEmpty())
if (aMessage.IsEmpty())
{
FinalizeCoapTransaction(*message, coapMetadata, NULL, NULL, NULL, OT_ERROR_ABORT);
FinalizeCoapTransaction(*request, coapMetadata, NULL, NULL, OT_ERROR_ABORT);
}
// Silently ignore non-empty reset messages (RFC 7252, p. 4.2).
break;
case OT_COAP_TYPE_ACKNOWLEDGMENT:
if (aResponseHeader.IsEmpty())
if (aMessage.IsEmpty())
{
// Empty acknowledgment.
if (coapMetadata.mConfirmable)
{
coapMetadata.mAcknowledged = true;
coapMetadata.UpdateIn(*message);
coapMetadata.UpdateIn(*request);
}
// Remove the message if response is not expected, otherwise await response.
if (coapMetadata.mResponseHandler == NULL)
{
DequeueMessage(*message);
DequeueMessage(*request);
}
}
else if (aResponseHeader.IsResponse() && aResponseHeader.IsTokenEqual(requestHeader))
else if (aMessage.IsResponse() && aMessage.IsTokenEqual(*request))
{
// Piggybacked response.
FinalizeCoapTransaction(*message, coapMetadata, &aResponseHeader, &aMessage, &aMessageInfo, OT_ERROR_NONE);
FinalizeCoapTransaction(*request, coapMetadata, &aMessage, &aMessageInfo, OT_ERROR_NONE);
}
// Silently ignore acknowledgments carrying requests (RFC 7252, p. 4.2)
@@ -606,45 +579,42 @@ void Coap::ProcessReceivedResponse(Header &aResponseHeader, Message &aMessage, c
case OT_COAP_TYPE_CONFIRMABLE:
// Send empty ACK if it is a CON message.
SendAck(aResponseHeader, aMessageInfo);
SendAck(aMessage, aMessageInfo);
// fall through
case OT_COAP_TYPE_NON_CONFIRMABLE:
// Separate response.
FinalizeCoapTransaction(*message, coapMetadata, &aResponseHeader, &aMessage, &aMessageInfo, OT_ERROR_NONE);
FinalizeCoapTransaction(*request, coapMetadata, &aMessage, &aMessageInfo, OT_ERROR_NONE);
break;
}
exit:
if (error == OT_ERROR_NONE && message == NULL)
if (error == OT_ERROR_NONE && request == NULL)
{
if (aResponseHeader.IsConfirmable() || aResponseHeader.IsNonConfirmable())
if (aMessage.IsConfirmable() || aMessage.IsNonConfirmable())
{
// Successfully parsed a header but no matching request was found - reject the message by sending reset.
SendReset(aResponseHeader, aMessageInfo);
SendReset(aMessage, aMessageInfo);
}
}
}
void Coap::ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Coap::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
char uriPath[Resource::kMaxReceivedUriPath] = "";
char * curUriPath = uriPath;
const Header::Option *coapOption;
Message * cachedResponse = NULL;
otError error = OT_ERROR_NOT_FOUND;
char uriPath[Resource::kMaxReceivedUriPath];
char * curUriPath = uriPath;
Message *cachedResponse = NULL;
otError error = OT_ERROR_NOT_FOUND;
if (mInterceptor != NULL)
{
SuccessOrExit(error = mInterceptor(aMessage, aMessageInfo, mContext));
}
aMessage.MoveOffset(aHeader.GetLength());
switch (mResponsesQueue.GetMatchedResponseCopy(aHeader, aMessageInfo, &cachedResponse))
switch (mResponsesQueue.GetMatchedResponseCopy(aMessage, aMessageInfo, &cachedResponse))
{
case OT_ERROR_NONE:
error = Send(*cachedResponse, aMessageInfo);
@@ -659,11 +629,9 @@ void Coap::ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6:
break;
}
coapOption = aHeader.GetFirstOption();
while (coapOption != NULL)
for (const otCoapOption *option = aMessage.GetFirstOption(); option != NULL; option = aMessage.GetNextOption())
{
switch (coapOption->mNumber)
switch (option->mNumber)
{
case OT_COAP_OPTION_URI_PATH:
if (curUriPath != uriPath)
@@ -671,17 +639,15 @@ void Coap::ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6:
*curUriPath++ = '/';
}
VerifyOrExit(coapOption->mLength < sizeof(uriPath) - static_cast<size_t>(curUriPath + 1 - uriPath));
VerifyOrExit(option->mLength < sizeof(uriPath) - static_cast<size_t>(curUriPath + 1 - uriPath));
memcpy(curUriPath, coapOption->mValue, coapOption->mLength);
curUriPath += coapOption->mLength;
aMessage.GetOptionValue(curUriPath);
curUriPath += option->mLength;
break;
default:
break;
}
coapOption = aHeader.GetNextOption();
}
curUriPath[0] = '\0';
@@ -690,7 +656,7 @@ void Coap::ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6:
{
if (strcmp(resource->mUriPath, uriPath) == 0)
{
resource->HandleRequest(aHeader, aMessage, aMessageInfo);
resource->HandleRequest(aMessage, aMessageInfo);
error = OT_ERROR_NONE;
ExitNow();
}
@@ -698,7 +664,7 @@ void Coap::ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6:
if (mDefaultHandler)
{
mDefaultHandler(mDefaultHandlerContext, &aHeader, &aMessage, &aMessageInfo);
mDefaultHandler(mDefaultHandlerContext, &aMessage, &aMessageInfo);
error = OT_ERROR_NONE;
}
@@ -710,7 +676,7 @@ exit:
if (error == OT_ERROR_NOT_FOUND)
{
SendNotFound(aHeader, aMessageInfo);
SendNotFound(aMessage, aMessageInfo);
}
if (cachedResponse != NULL)
@@ -759,7 +725,7 @@ ResponsesQueue::ResponsesQueue(Instance &aInstance)
{
}
otError ResponsesQueue::GetMatchedResponseCopy(const Header & aHeader,
otError ResponsesQueue::GetMatchedResponseCopy(const Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
Message ** aResponse)
{
@@ -767,9 +733,9 @@ otError ResponsesQueue::GetMatchedResponseCopy(const Header & aHeader,
Message * message;
EnqueuedResponseHeader enqueuedResponseHeader;
Ip6::MessageInfo messageInfo;
Header header;
for (message = mQueue.GetHead(); message != NULL; message = message->GetNext())
for (message = static_cast<Message *>(mQueue.GetHead()); message != NULL;
message = static_cast<Message *>(message->GetNext()))
{
enqueuedResponseHeader.ReadFrom(*message);
messageInfo = enqueuedResponseHeader.GetMessageInfo();
@@ -786,18 +752,12 @@ otError ResponsesQueue::GetMatchedResponseCopy(const Header & aHeader,
}
// Check Message Id
if (header.FromMessage(*message, sizeof(EnqueuedResponseHeader)) != OT_ERROR_NONE)
if (message->GetMessageId() != aRequest.GetMessageId())
{
continue;
}
if (header.GetMessageId() != aHeader.GetMessageId())
{
continue;
}
*aResponse = message->Clone();
VerifyOrExit(*aResponse != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((*aResponse = message->Clone()) != NULL, error = OT_ERROR_NO_BUFS);
EnqueuedResponseHeader::RemoveFrom(**aResponse);
@@ -809,14 +769,14 @@ exit:
return error;
}
void ResponsesQueue::EnqueueResponse(const Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void ResponsesQueue::EnqueueResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Message * copy;
EnqueuedResponseHeader enqueuedResponseHeader(aMessageInfo);
uint16_t messageCount;
uint16_t bufferCount;
switch (GetMatchedResponseCopy(aHeader, aMessageInfo, &copy))
switch (GetMatchedResponseCopy(aMessage, aMessageInfo, &copy))
{
case OT_ERROR_NOT_FOUND:
break;
@@ -838,8 +798,7 @@ void ResponsesQueue::EnqueueResponse(const Header &aHeader, Message &aMessage, c
DequeueOldestResponse();
}
copy = aMessage.Clone();
VerifyOrExit(copy != NULL);
VerifyOrExit((copy = aMessage.Clone()) != NULL);
enqueuedResponseHeader.AppendTo(*copy);
mQueue.Enqueue(*copy);
@@ -857,7 +816,7 @@ void ResponsesQueue::DequeueOldestResponse(void)
{
Message *message;
VerifyOrExit((message = mQueue.GetHead()) != NULL);
VerifyOrExit((message = static_cast<Message *>(mQueue.GetHead())) != NULL);
DequeueResponse(*message);
exit:
@@ -868,7 +827,7 @@ void ResponsesQueue::DequeueAllResponses(void)
{
Message *message;
while ((message = mQueue.GetHead()) != NULL)
while ((message = static_cast<Message *>(mQueue.GetHead())) != NULL)
{
DequeueResponse(*message);
}
@@ -884,7 +843,7 @@ void ResponsesQueue::HandleTimer(void)
Message * message;
EnqueuedResponseHeader enqueuedResponseHeader;
while ((message = mQueue.GetHead()) != NULL)
while ((message = static_cast<Message *>(mQueue.GetHead())) != NULL)
{
enqueuedResponseHeader.ReadFrom(*message);
src/core/coap/coap.hpp
+31 -35
View File
@@ -33,7 +33,7 @@
#include <openthread/coap.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/debug.hpp"
#include "common/locator.hpp"
#include "common/message.hpp"
@@ -238,9 +238,9 @@ public:
const char *GetUriPath(void) const { return mUriPath; };
private:
void HandleRequest(Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
void HandleRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
mHandler(mContext, &aHeader, &aMessage, &aMessageInfo);
mHandler(mContext, &aMessage, &aMessageInfo);
}
};
@@ -363,12 +363,11 @@ public:
* response is not added.
* The CoAP response is copied before it is added to the cache.
*
* @param[in] aHeader A reference to a CoAP header.
* @param[in] aMessage The CoAP response to add to the cache.
* @param[in] aMessageInfo The message info corresponding to @p aMessage.
*
*/
void EnqueueResponse(const Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void EnqueueResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
/**
* Remove the oldest response from the cache.
@@ -385,7 +384,7 @@ public:
/**
* Get a copy of CoAP response from the cache that matches given Message ID and source endpoint.
*
* @param[in] aHeader The CoAP message header containing Message ID.
* @param[in] aRequest The CoAP message containing Message ID.
* @param[in] aMessageInfo The message info containing source endpoint address and port.
* @param[out] aResponse A pointer to a copy of a cached CoAP response matching given arguments.
*
@@ -394,7 +393,7 @@ public:
* @retval OT_ERROR_NOT_FOUND Matching response not found.
*
*/
otError GetMatchedResponseCopy(const Header &aHeader, const Ip6::MessageInfo &aMessageInfo, Message **aResponse);
otError GetMatchedResponseCopy(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo, Message **aResponse);
/**
* Get a reference to the cached CoAP responses queue.
@@ -505,13 +504,12 @@ public:
* @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to
* OT_MESSAGE_PRIORITY_NORMAL by default.
*
* @param[in] aHeader A reference to a CoAP header that is used to create the message.
* @param[in] aSettings A pointer to the message settings or NULL to set default settings.
*
* @returns A pointer to the message or NULL if failed to allocate message.
*
*/
Message *NewMessage(const Header &aHeader, const otMessageSettings *aSettings = NULL);
Message *NewMessage(const otMessageSettings *aSettings = NULL);
/**
* This method sends a CoAP message.
@@ -537,80 +535,80 @@ public:
/**
* This method sends a CoAP reset message.
*
* @param[in] aRequestHeader A reference to the CoAP Header that was used in CoAP request.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
*
* @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.
* @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.
* @retval OT_ERROR_INVALID_ARGS The @p aRequestHeader header is not of confirmable type.
* @retval OT_ERROR_INVALID_ARGS The @p aRequest is not of confirmable type.
*
*/
otError SendReset(Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError SendReset(Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendEmptyMessage(OT_COAP_TYPE_RESET, aRequestHeader, aMessageInfo);
return SendEmptyMessage(OT_COAP_TYPE_RESET, aRequest, aMessageInfo);
};
/**
* This method sends header-only CoAP response message.
*
* @param[in] aCode The CoAP code of this response.
* @param[in] aRequestHeader A reference to the CoAP Header that was used in CoAP request.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
*
* @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.
* @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.
* @retval OT_ERROR_INVALID_ARGS The @p aRequestHeader header is not of confirmable type.
* @retval OT_ERROR_INVALID_ARGS The @p aRequest header is not of confirmable type.
*
*/
otError SendHeaderResponse(Header::Code aCode, const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo);
otError SendHeaderResponse(Message::Code aCode, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
/**
* This method sends a CoAP ACK empty message which is used in Separate Response for confirmable requests.
*
* @param[in] aRequestHeader A reference to the CoAP Header that was used in CoAP request.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
*
* @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.
* @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.
* @retval OT_ERROR_INVALID_ARGS The @p aRequestHeader header is not of confirmable type.
* @retval OT_ERROR_INVALID_ARGS The @p aRequest header is not of confirmable type.
*
*/
otError SendAck(const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError SendAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendEmptyMessage(OT_COAP_TYPE_ACKNOWLEDGMENT, aRequestHeader, aMessageInfo);
return SendEmptyMessage(OT_COAP_TYPE_ACKNOWLEDGMENT, aRequest, aMessageInfo);
};
/**
* This method sends a CoAP ACK message on which a dummy CoAP response is piggybacked.
*
* @param[in] aRequestHeader A reference to the CoAP Header that was used in CoAP request.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
*
* @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.
* @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.
* @retval OT_ERROR_INVALID_ARGS The @p aRequestHeader header is not of confirmable type.
* @retval OT_ERROR_INVALID_ARGS The @p aRequest header is not of confirmable type.
*
*/
otError SendEmptyAck(const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError SendEmptyAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return (aRequestHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE
? SendHeaderResponse(OT_COAP_CODE_CHANGED, aRequestHeader, aMessageInfo)
return (aRequest.GetType() == OT_COAP_TYPE_CONFIRMABLE
? SendHeaderResponse(OT_COAP_CODE_CHANGED, aRequest, aMessageInfo)
: OT_ERROR_INVALID_ARGS);
}
/**
* This method sends a header-only CoAP message to indicate no resource matched for the request.
*
* @param[in] aRequestHeader A reference to the CoAP Header that was used in CoAP request.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
*
* @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.
* @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.
*
*/
otError SendNotFound(const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
otError SendNotFound(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendHeaderResponse(OT_COAP_CODE_NOT_FOUND, aRequestHeader, aMessageInfo);
return SendHeaderResponse(OT_COAP_CODE_NOT_FOUND, aRequest, aMessageInfo);
}
/**
@@ -673,7 +671,7 @@ protected:
* @param[in] aMessageInfo A reference to the message info associated with @p aMessage.
*
*/
virtual void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
virtual void Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Ip6::UdpSocket mSocket;
@@ -685,22 +683,20 @@ private:
Message *CopyAndEnqueueMessage(const Message &aMessage, uint16_t aCopyLength, const CoapMetadata &aCoapMetadata);
void DequeueMessage(Message &aMessage);
Message *FindRelatedRequest(const Header & aResponseHeader,
Message *FindRelatedRequest(const Message & aResponse,
const Ip6::MessageInfo &aMessageInfo,
Header & aRequestHeader,
CoapMetadata & aCoapMetadata);
void FinalizeCoapTransaction(Message & aRequest,
const CoapMetadata & aCoapMetadata,
Header * aResponseHeader,
Message * aResponse,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
void ProcessReceivedRequest(Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void ProcessReceivedResponse(Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendCopy(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendEmptyMessage(Header::Type aType, const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo);
otError SendEmptyMessage(Message::Type aType, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
MessageQueue mPendingRequests;
uint16_t mMessageId;
src/core/coap/coap_header.cpp
-541
View File
@@ -1,541 +0,0 @@
/*
* 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
* This file implements the CoAP header generation and parsing.
*/
#include "coap_header.hpp"
#include "coap/coap.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
#include "common/instance.hpp"
#include "common/random.hpp"
namespace ot {
namespace Coap {
void Header::Init(void)
{
mHeaderLength = kMinHeaderLength;
mOptionLast = 0;
mFirstOptionOffset = 0;
mNextOptionOffset = 0;
memset(&mOption, 0, sizeof(mOption));
memset(&mHeader, 0, sizeof(mHeader));
SetVersion(kVersion1);
}
void Header::Init(Type aType, Code aCode)
{
Init();
SetType(aType);
SetCode(aCode);
}
otError Header::FromMessage(const Message &aMessage, uint16_t aMetadataSize)
{
otError error = OT_ERROR_PARSE;
uint16_t offset = aMessage.GetOffset();
uint16_t length = aMessage.GetLength() - aMessage.GetOffset();
uint8_t tokenLength;
bool firstOption = true;
uint16_t optionDelta;
uint16_t optionLength;
length -= aMetadataSize;
Init();
VerifyOrExit(kTokenOffset <= length);
aMessage.Read(offset, kTokenOffset, mHeader.mBytes);
mHeaderLength = kTokenOffset;
offset += kTokenOffset;
VerifyOrExit(GetVersion() == 1);
tokenLength = GetTokenLength();
VerifyOrExit(tokenLength <= OT_COAP_MAX_TOKEN_LENGTH && (mHeaderLength + tokenLength) <= length);
aMessage.Read(offset, tokenLength, mHeader.mBytes + mHeaderLength);
mHeaderLength += tokenLength;
offset += tokenLength;
while (mHeaderLength < length)
{
VerifyOrExit(mHeaderLength + kMaxOptionHeaderSize <= kMaxHeaderLength);
aMessage.Read(offset, kMaxOptionHeaderSize, mHeader.mBytes + mHeaderLength);
if (mHeader.mBytes[mHeaderLength] == 0xff)
{
mHeaderLength += sizeof(uint8_t);
// RFC7252: The presence of a marker followed by a zero-length payload MUST be processed
// as a message format error.
VerifyOrExit(mHeaderLength < length);
ExitNow(error = OT_ERROR_NONE);
}
if (firstOption)
{
mFirstOptionOffset = mHeaderLength;
}
optionDelta = mHeader.mBytes[mHeaderLength] >> 4;
optionLength = mHeader.mBytes[mHeaderLength] & 0xf;
mHeaderLength += sizeof(uint8_t);
offset += sizeof(uint8_t);
if (optionDelta < kOption1ByteExtension)
{
// do nothing
}
else if (optionDelta == kOption1ByteExtension)
{
optionDelta = kOption1ByteExtensionOffset + mHeader.mBytes[mHeaderLength];
mHeaderLength += sizeof(uint8_t);
offset += sizeof(uint8_t);
}
else if (optionDelta == kOption2ByteExtension)
{
optionDelta = kOption2ByteExtensionOffset + static_cast<uint16_t>((mHeader.mBytes[mHeaderLength] << 8) |
(mHeader.mBytes[mHeaderLength + 1]));
mHeaderLength += sizeof(uint16_t);
offset += sizeof(uint16_t);
}
else
{
ExitNow(error = OT_ERROR_PARSE);
}
if (optionLength < kOption1ByteExtension)
{
// do nothing
}
else if (optionLength == kOption1ByteExtension)
{
optionLength = kOption1ByteExtensionOffset + mHeader.mBytes[mHeaderLength];
mHeaderLength += sizeof(uint8_t);
offset += sizeof(uint8_t);
}
else if (optionLength == kOption2ByteExtension)
{
optionLength = kOption2ByteExtensionOffset + static_cast<uint16_t>((mHeader.mBytes[mHeaderLength] << 8) |
(mHeader.mBytes[mHeaderLength + 1]));
mHeaderLength += sizeof(uint16_t);
offset += sizeof(uint16_t);
}
else
{
ExitNow(error = OT_ERROR_PARSE);
}
if (firstOption)
{
mOption.mNumber = optionDelta;
mOption.mLength = optionLength;
mOption.mValue = mHeader.mBytes + mHeaderLength;
mNextOptionOffset = mHeaderLength + optionLength;
firstOption = false;
}
VerifyOrExit(mHeaderLength + optionLength <= kMaxHeaderLength);
VerifyOrExit(mHeaderLength + optionLength <= length);
aMessage.Read(offset, optionLength, mHeader.mBytes + mHeaderLength);
mHeaderLength += optionLength;
offset += optionLength;
}
if (mHeaderLength == length)
{
// No payload present - return success.
error = OT_ERROR_NONE;
}
exit:
// In case any step failed, prevent access to corrupt Option
if (error != OT_ERROR_NONE)
{
mFirstOptionOffset = 0;
}
return error;
}
otError Header::AppendOption(const Option &aOption)
{
otError error = OT_ERROR_NONE;
uint8_t *buf = mHeader.mBytes + mHeaderLength;
uint8_t *cur = buf + 1;
uint16_t optionDelta = aOption.mNumber - mOptionLast;
uint16_t optionLength;
// Assure that no option is inserted out of order.
VerifyOrExit(aOption.mNumber >= mOptionLast, error = OT_ERROR_INVALID_ARGS);
// Calculate the total option size and check the buffers.
optionLength = 1 + aOption.mLength;
optionLength += optionDelta < kOption1ByteExtensionOffset ? 0 : (optionDelta < kOption2ByteExtensionOffset ? 1 : 2);
optionLength +=
aOption.mLength < kOption1ByteExtensionOffset ? 0 : (aOption.mLength < kOption2ByteExtensionOffset ? 1 : 2);
VerifyOrExit(mHeaderLength + optionLength < kMaxHeaderLength, error = OT_ERROR_NO_BUFS);
// Insert option delta.
if (optionDelta < kOption1ByteExtensionOffset)
{
*buf = (optionDelta << Option::kOptionDeltaOffset) & Option::kOptionDeltaMask;
}
else if (optionDelta < kOption2ByteExtensionOffset)
{
*buf |= kOption1ByteExtension << Option::kOptionDeltaOffset;
*cur++ = (optionDelta - kOption1ByteExtensionOffset) & 0xff;
}
else
{
*buf |= kOption2ByteExtension << Option::kOptionDeltaOffset;
optionDelta -= kOption2ByteExtensionOffset;
*cur++ = optionDelta >> 8;
*cur++ = optionDelta & 0xff;
}
// Insert option length.
if (aOption.mLength < kOption1ByteExtensionOffset)
{
*buf |= aOption.mLength;
}
else if (aOption.mLength < kOption2ByteExtensionOffset)
{
*buf |= kOption1ByteExtension;
*cur++ = (aOption.mLength - kOption1ByteExtensionOffset) & 0xff;
}
else
{
*buf |= kOption2ByteExtension;
optionLength = aOption.mLength - kOption2ByteExtensionOffset;
*cur++ = optionLength >> 8;
*cur++ = optionLength & 0xff;
}
// Insert option value.
memcpy(cur, aOption.mValue, aOption.mLength);
cur += aOption.mLength;
mHeaderLength += static_cast<uint16_t>(cur - buf);
mOptionLast = aOption.mNumber;
exit:
return error;
}
otError Header::AppendUintOption(uint16_t aNumber, uint32_t aValue)
{
Option coapOption;
aValue = Encoding::BigEndian::HostSwap32(aValue);
coapOption.mNumber = aNumber;
coapOption.mLength = 4;
coapOption.mValue = reinterpret_cast<uint8_t *>(&aValue);
// skip preceding zeros
while (coapOption.mValue[0] == 0 && coapOption.mLength > 0)
{
coapOption.mValue++;
coapOption.mLength--;
}
return AppendOption(coapOption);
}
otError Header::AppendStringOption(uint16_t aNumber, const char *aValue)
{
Option coapOption;
coapOption.mNumber = aNumber;
coapOption.mLength = static_cast<uint16_t>(strlen(aValue));
coapOption.mValue = reinterpret_cast<const uint8_t *>(aValue);
return AppendOption(coapOption);
}
otError Header::AppendObserveOption(uint32_t aObserve)
{
return AppendUintOption(OT_COAP_OPTION_OBSERVE, aObserve & 0xFFFFFF);
}
otError Header::AppendUriPathOptions(const char *aUriPath)
{
otError error = OT_ERROR_NONE;
const char *cur = aUriPath;
const char *end;
Option coapOption;
coapOption.mNumber = OT_COAP_OPTION_URI_PATH;
while ((end = strchr(cur, '/')) != NULL)
{
coapOption.mLength = static_cast<uint16_t>(end - cur);
coapOption.mValue = reinterpret_cast<const uint8_t *>(cur);
SuccessOrExit(error = AppendOption(coapOption));
cur = end + 1;
}
SuccessOrExit(error = AppendStringOption(OT_COAP_OPTION_URI_PATH, cur));
exit:
return error;
}
otError Header::AppendProxyUriOption(const char *aProxyUri)
{
return AppendStringOption(OT_COAP_OPTION_PROXY_URI, aProxyUri);
}
otError Header::AppendContentFormatOption(otCoapOptionContentFormat aContentFormat)
{
return AppendUintOption(OT_COAP_OPTION_CONTENT_FORMAT, static_cast<uint32_t>(aContentFormat));
}
otError Header::AppendMaxAgeOption(uint32_t aMaxAge)
{
return AppendUintOption(OT_COAP_OPTION_MAX_AGE, aMaxAge);
}
otError Header::AppendUriQueryOption(const char *aUriQuery)
{
return AppendStringOption(OT_COAP_OPTION_URI_QUERY, aUriQuery);
}
const Header::Option *Header::GetFirstOption(void)
{
const Option *rval = NULL;
VerifyOrExit(mFirstOptionOffset > 0);
memset(&mOption, 0, sizeof(mOption));
mNextOptionOffset = mFirstOptionOffset;
rval = GetNextOption();
exit:
return rval;
}
const Header::Option *Header::GetNextOption(void)
{
Option * rval = NULL;
uint16_t optionDelta;
uint16_t optionLength;
VerifyOrExit(mNextOptionOffset < mHeaderLength);
optionDelta = mHeader.mBytes[mNextOptionOffset] >> 4;
optionLength = mHeader.mBytes[mNextOptionOffset] & 0xf;
mNextOptionOffset += sizeof(uint8_t);
if (optionDelta < kOption1ByteExtension)
{
// do nothing
}
else if (optionDelta == kOption1ByteExtension)
{
optionDelta = kOption1ByteExtensionOffset + mHeader.mBytes[mNextOptionOffset];
mNextOptionOffset += sizeof(uint8_t);
}
else if (optionDelta == kOption2ByteExtension)
{
optionDelta = kOption2ByteExtensionOffset + static_cast<uint16_t>((mHeader.mBytes[mNextOptionOffset] << 8) |
mHeader.mBytes[mNextOptionOffset + 1]);
mNextOptionOffset += sizeof(uint16_t);
}
else
{
ExitNow();
}
if (optionLength < kOption1ByteExtension)
{
// do nothing
}
else if (optionLength == kOption1ByteExtension)
{
optionLength = kOption1ByteExtensionOffset + mHeader.mBytes[mNextOptionOffset];
mNextOptionOffset += sizeof(uint8_t);
}
else if (optionLength == kOption2ByteExtension)
{
optionLength = kOption2ByteExtensionOffset + static_cast<uint16_t>((mHeader.mBytes[mNextOptionOffset] << 8) |
mHeader.mBytes[mNextOptionOffset + 1]);
mNextOptionOffset += sizeof(uint16_t);
}
else
{
ExitNow();
}
mOption.mNumber += optionDelta;
mOption.mLength = optionLength;
mOption.mValue = mHeader.mBytes + mNextOptionOffset;
mNextOptionOffset += optionLength;
rval = static_cast<Option *>(&mOption);
exit:
return rval;
}
otError Header::SetPayloadMarker(void)
{
otError error = OT_ERROR_NONE;
VerifyOrExit(mHeaderLength < kMaxHeaderLength, error = OT_ERROR_NO_BUFS);
mHeader.mBytes[mHeaderLength++] = 0xff;
exit:
return error;
}
void Header::SetToken(uint8_t aTokenLength)
{
uint8_t token[OT_COAP_MAX_TOKEN_LENGTH] = {0};
assert(aTokenLength <= sizeof(token));
Random::FillBuffer(token, aTokenLength);
SetToken(token, aTokenLength);
}
void Header::SetDefaultResponseHeader(const Header &aRequestHeader)
{
Init(OT_COAP_TYPE_ACKNOWLEDGMENT, OT_COAP_CODE_CHANGED);
SetMessageId(aRequestHeader.GetMessageId());
SetToken(aRequestHeader.GetToken(), aRequestHeader.GetTokenLength());
}
#if OPENTHREAD_ENABLE_APPLICATION_COAP
const char *Header::CodeToString(void) const
{
const char *mCodeString;
switch (mHeader.mFields.mCode)
{
case OT_COAP_CODE_INTERNAL_ERROR:
mCodeString = "InternalError";
break;
case OT_COAP_CODE_METHOD_NOT_ALLOWED:
mCodeString = "MethodNotAllowed";
break;
case OT_COAP_CODE_CONTENT:
mCodeString = "Content";
break;
case OT_COAP_CODE_EMPTY:
mCodeString = "Empty";
break;
case OT_COAP_CODE_GET:
mCodeString = "Get";
break;
case OT_COAP_CODE_POST:
mCodeString = "Post";
break;
case OT_COAP_CODE_PUT:
mCodeString = "Put";
break;
case OT_COAP_CODE_DELETE:
mCodeString = "Delete";
break;
case OT_COAP_CODE_NOT_FOUND:
mCodeString = "NotFound";
break;
case OT_COAP_CODE_UNSUPPORTED_FORMAT:
mCodeString = "UnsupportedFormat";
break;
case OT_COAP_CODE_RESPONSE_MIN:
mCodeString = "ResponseMin";
break;
case OT_COAP_CODE_CREATED:
mCodeString = "Created";
break;
case OT_COAP_CODE_DELETED:
mCodeString = "Deleted";
break;
case OT_COAP_CODE_VALID:
mCodeString = "Valid";
break;
case OT_COAP_CODE_CHANGED:
mCodeString = "Changed";
break;
case OT_COAP_CODE_BAD_REQUEST:
mCodeString = "BadRequest";
break;
case OT_COAP_CODE_UNAUTHORIZED:
mCodeString = "Unauthorized";
break;
case OT_COAP_CODE_BAD_OPTION:
mCodeString = "BadOption";
break;
case OT_COAP_CODE_FORBIDDEN:
mCodeString = "Forbidden";
break;
case OT_COAP_CODE_NOT_ACCEPTABLE:
mCodeString = "NotAcceptable";
break;
case OT_COAP_CODE_PRECONDITION_FAILED:
mCodeString = "PreconditionFailed";
break;
case OT_COAP_CODE_REQUEST_TOO_LARGE:
mCodeString = "RequestTooLarge";
break;
case OT_COAP_CODE_NOT_IMPLEMENTED:
mCodeString = "NotImplemented";
break;
case OT_COAP_CODE_BAD_GATEWAY:
mCodeString = "BadGateway";
break;
case OT_COAP_CODE_SERVICE_UNAVAILABLE:
mCodeString = "ServiceUnavailable";
break;
case OT_COAP_CODE_GATEWAY_TIMEOUT:
mCodeString = "GatewayTimeout";
break;
case OT_COAP_CODE_PROXY_NOT_SUPPORTED:
mCodeString = "ProxyNotSupported";
break;
default:
mCodeString = "Unknown";
break;
}
return mCodeString;
}
#endif // OPENTHREAD_ENABLE_APPLICATION_COAP
} // namespace Coap
} // namespace ot
src/core/coap/coap_message.cpp
+459
View File
@@ -0,0 +1,459 @@
/*
* 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
* This file implements the CoAP message generation and parsing.
*/
#include "coap_message.hpp"
#include "coap/coap.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
#include "common/instance.hpp"
#include "common/random.hpp"
namespace ot {
namespace Coap {
void Message::Init(void)
{
memset(&GetHelpData(), 0, sizeof(GetHelpData()));
SetVersion(kVersion1);
SetOffset(0);
GetHelpData().mHeaderLength = kMinHeaderLength;
SetLength(GetHelpData().mHeaderLength);
}
void Message::Init(Type aType, Code aCode)
{
Init();
SetType(aType);
SetCode(aCode);
}
void Message::Finish(void)
{
Write(0, GetOptionStart(), &GetHelpData().mHeader);
}
otError Message::AppendOption(uint16_t aNumber, uint16_t aLength, const void *aValue)
{
otError error = OT_ERROR_NONE;
uint16_t optionDelta = aNumber - GetHelpData().mOptionLast;
uint16_t optionLength;
uint8_t buf[kMaxOptionHeaderSize] = {0};
uint8_t *cur = &buf[1];
// Assure that no option is inserted out of order.
VerifyOrExit(aNumber >= GetHelpData().mOptionLast, error = OT_ERROR_INVALID_ARGS);
// Calculate the total option size and check the buffers.
optionLength = 1 + aLength;
optionLength += optionDelta < kOption1ByteExtensionOffset ? 0 : (optionDelta < kOption2ByteExtensionOffset ? 1 : 2);
optionLength += aLength < kOption1ByteExtensionOffset ? 0 : (aLength < kOption2ByteExtensionOffset ? 1 : 2);
VerifyOrExit(GetLength() + optionLength < kMaxHeaderLength, error = OT_ERROR_NO_BUFS);
// Insert option delta.
if (optionDelta < kOption1ByteExtensionOffset)
{
*buf = (optionDelta << kOptionDeltaOffset) & kOptionDeltaMask;
}
else if (optionDelta < kOption2ByteExtensionOffset)
{
*buf |= kOption1ByteExtension << kOptionDeltaOffset;
*cur++ = (optionDelta - kOption1ByteExtensionOffset) & 0xff;
}
else
{
*buf |= kOption2ByteExtension << kOptionDeltaOffset;
optionDelta -= kOption2ByteExtensionOffset;
*cur++ = optionDelta >> 8;
*cur++ = optionDelta & 0xff;
}
// Insert option length.
if (aLength < kOption1ByteExtensionOffset)
{
*buf |= aLength;
}
else if (aLength < kOption2ByteExtensionOffset)
{
*buf |= kOption1ByteExtension;
*cur++ = (aLength - kOption1ByteExtensionOffset) & 0xff;
}
else
{
*buf |= kOption2ByteExtension;
optionLength = aLength - kOption2ByteExtensionOffset;
*cur++ = optionLength >> 8;
*cur++ = optionLength & 0xff;
}
Append(buf, static_cast<uint16_t>(cur - buf));
Append(aValue, aLength);
GetHelpData().mOptionLast = aNumber;
GetHelpData().mHeaderLength = GetLength();
exit:
return error;
}
otError Message::AppendUintOption(uint16_t aNumber, uint32_t aValue)
{
uint16_t length = sizeof(aValue);
uint8_t *value;
aValue = Encoding::BigEndian::HostSwap32(aValue);
value = reinterpret_cast<uint8_t *>(&aValue);
// skip preceding zeros
while (value[0] == 0 && length > 0)
{
value++;
length--;
}
return AppendOption(aNumber, length, value);
}
otError Message::AppendStringOption(uint16_t aNumber, const char *aValue)
{
return AppendOption(aNumber, static_cast<uint16_t>(strlen(aValue)), aValue);
}
otError Message::AppendObserveOption(uint32_t aObserve)
{
return AppendUintOption(OT_COAP_OPTION_OBSERVE, aObserve & 0xFFFFFF);
}
otError Message::AppendUriPathOptions(const char *aUriPath)
{
otError error = OT_ERROR_NONE;
const char *cur = aUriPath;
const char *end;
while ((end = strchr(cur, '/')) != NULL)
{
SuccessOrExit(error = AppendOption(OT_COAP_OPTION_URI_PATH, static_cast<uint16_t>(end - cur), cur));
cur = end + 1;
}
SuccessOrExit(error = AppendStringOption(OT_COAP_OPTION_URI_PATH, cur));
exit:
return error;
}
otError Message::AppendProxyUriOption(const char *aProxyUri)
{
return AppendStringOption(OT_COAP_OPTION_PROXY_URI, aProxyUri);
}
otError Message::AppendContentFormatOption(otCoapOptionContentFormat aContentFormat)
{
return AppendUintOption(OT_COAP_OPTION_CONTENT_FORMAT, static_cast<uint32_t>(aContentFormat));
}
otError Message::AppendMaxAgeOption(uint32_t aMaxAge)
{
return AppendUintOption(OT_COAP_OPTION_MAX_AGE, aMaxAge);
}
otError Message::AppendUriQueryOption(const char *aUriQuery)
{
return AppendStringOption(OT_COAP_OPTION_URI_QUERY, aUriQuery);
}
const otCoapOption *Message::GetFirstOption(void)
{
const otCoapOption *option = NULL;
memset(&GetHelpData().mOption, 0, sizeof(GetHelpData().mOption));
GetHelpData().mNextOptionOffset = GetHelpData().mHeaderOffset + GetOptionStart();
VerifyOrExit(GetLength() - GetHelpData().mHeaderOffset > GetOptionStart());
option = GetNextOption();
exit:
return option;
}
const otCoapOption *Message::GetNextOption(void)
{
otError error = OT_ERROR_NONE;
uint16_t optionDelta;
uint16_t optionLength;
uint8_t buf[kMaxOptionHeaderSize];
uint8_t * cur = buf + 1;
otCoapOption *rval = NULL;
VerifyOrExit(GetHelpData().mNextOptionOffset < GetLength(), error = OT_ERROR_NOT_FOUND);
Read(GetHelpData().mNextOptionOffset, sizeof(buf), buf);
optionDelta = buf[0] >> 4;
optionLength = buf[0] & 0xf;
GetHelpData().mNextOptionOffset += sizeof(uint8_t);
if (optionDelta < kOption1ByteExtension)
{
// do nothing
}
else if (optionDelta == kOption1ByteExtension)
{
optionDelta = kOption1ByteExtensionOffset + cur[0];
GetHelpData().mNextOptionOffset += sizeof(uint8_t);
cur++;
}
else if (optionDelta == kOption2ByteExtension)
{
optionDelta = kOption2ByteExtensionOffset + static_cast<uint16_t>((cur[0] << 8) | cur[1]);
GetHelpData().mNextOptionOffset += sizeof(uint16_t);
cur += 2;
}
else
{
VerifyOrExit(optionLength == 0xf, error = OT_ERROR_PARSE);
ExitNow(error = OT_ERROR_NOT_FOUND);
}
if (optionLength < kOption1ByteExtension)
{
// do nothing
}
else if (optionLength == kOption1ByteExtension)
{
optionLength = kOption1ByteExtensionOffset + cur[0];
GetHelpData().mNextOptionOffset += sizeof(uint8_t);
}
else if (optionLength == kOption2ByteExtension)
{
optionLength = kOption2ByteExtensionOffset + static_cast<uint16_t>((cur[0] << 8) | cur[1]);
GetHelpData().mNextOptionOffset += sizeof(uint16_t);
}
else
{
ExitNow();
}
rval = &GetHelpData().mOption;
rval->mNumber += optionDelta;
rval->mLength = optionLength;
GetHelpData().mNextOptionOffset += optionLength;
exit:
if (error == OT_ERROR_PARSE)
{
GetHelpData().mNextOptionOffset = 0;
}
return rval;
}
otError Message::GetOptionValue(void *aValue) const
{
otError error = OT_ERROR_NONE;
const otCoapOption &option = GetHelpData().mOption;
VerifyOrExit(GetHelpData().mNextOptionOffset > 0, error = OT_ERROR_NOT_FOUND);
VerifyOrExit(Read(GetHelpData().mNextOptionOffset - option.mLength, option.mLength, aValue) == option.mLength,
error = OT_ERROR_PARSE);
exit:
return error;
}
otError Message::SetPayloadMarker(void)
{
otError error = OT_ERROR_NONE;
uint8_t marker = 0xff;
VerifyOrExit(GetLength() < kMaxHeaderLength, error = OT_ERROR_NO_BUFS);
Append(&marker, sizeof(marker));
GetHelpData().mHeaderLength = GetLength();
exit:
return error;
}
otError Message::ParseHeader(void)
{
otError error = OT_ERROR_NONE;
assert(mBuffer.mHead.mData + mBuffer.mHead.mInfo.mReserved >=
reinterpret_cast<uint8_t *>(&GetHelpData()) + sizeof(GetHelpData()));
GetHelpData().mHeaderOffset = GetOffset();
Read(GetHelpData().mHeaderOffset, sizeof(GetHelpData().mHeader), &GetHelpData().mHeader);
for (const otCoapOption *option = GetFirstOption(); option != NULL; option = GetNextOption())
{
}
VerifyOrExit(GetHelpData().mNextOptionOffset > 0, error = OT_ERROR_PARSE);
GetHelpData().mHeaderLength = GetHelpData().mNextOptionOffset - GetHelpData().mHeaderOffset;
MoveOffset(GetHelpData().mHeaderLength);
exit:
return error;
}
void Message::SetToken(const uint8_t *aToken, uint8_t aTokenLength)
{
GetHelpData().mHeader.mVersionTypeToken = (GetHelpData().mHeader.mVersionTypeToken & ~kTokenLengthMask) |
((aTokenLength << kTokenLengthOffset) & kTokenLengthMask);
memcpy(GetHelpData().mHeader.mToken, aToken, aTokenLength);
GetHelpData().mHeaderLength += aTokenLength;
SetLength(GetHelpData().mHeaderLength);
}
void Message::SetToken(uint8_t aTokenLength)
{
uint8_t token[kMaxTokenLength] = {0};
assert(aTokenLength <= sizeof(token));
Random::FillBuffer(token, aTokenLength);
SetToken(token, aTokenLength);
}
void Message::SetDefaultResponseHeader(const Message &aRequest)
{
Init(OT_COAP_TYPE_ACKNOWLEDGMENT, OT_COAP_CODE_CHANGED);
SetMessageId(aRequest.GetMessageId());
SetToken(aRequest.GetToken(), aRequest.GetTokenLength());
}
#if OPENTHREAD_ENABLE_APPLICATION_COAP
const char *Message::CodeToString(void) const
{
const char *codeString;
switch (GetCode())
{
case OT_COAP_CODE_INTERNAL_ERROR:
codeString = "InternalError";
break;
case OT_COAP_CODE_METHOD_NOT_ALLOWED:
codeString = "MethodNotAllowed";
break;
case OT_COAP_CODE_CONTENT:
codeString = "Content";
break;
case OT_COAP_CODE_EMPTY:
codeString = "Empty";
break;
case OT_COAP_CODE_GET:
codeString = "Get";
break;
case OT_COAP_CODE_POST:
codeString = "Post";
break;
case OT_COAP_CODE_PUT:
codeString = "Put";
break;
case OT_COAP_CODE_DELETE:
codeString = "Delete";
break;
case OT_COAP_CODE_NOT_FOUND:
codeString = "NotFound";
break;
case OT_COAP_CODE_UNSUPPORTED_FORMAT:
codeString = "UnsupportedFormat";
break;
case OT_COAP_CODE_RESPONSE_MIN:
codeString = "ResponseMin";
break;
case OT_COAP_CODE_CREATED:
codeString = "Created";
break;
case OT_COAP_CODE_DELETED:
codeString = "Deleted";
break;
case OT_COAP_CODE_VALID:
codeString = "Valid";
break;
case OT_COAP_CODE_CHANGED:
codeString = "Changed";
break;
case OT_COAP_CODE_BAD_REQUEST:
codeString = "BadRequest";
break;
case OT_COAP_CODE_UNAUTHORIZED:
codeString = "Unauthorized";
break;
case OT_COAP_CODE_BAD_OPTION:
codeString = "BadOption";
break;
case OT_COAP_CODE_FORBIDDEN:
codeString = "Forbidden";
break;
case OT_COAP_CODE_NOT_ACCEPTABLE:
codeString = "NotAcceptable";
break;
case OT_COAP_CODE_PRECONDITION_FAILED:
codeString = "PreconditionFailed";
break;
case OT_COAP_CODE_REQUEST_TOO_LARGE:
codeString = "RequestTooLarge";
break;
case OT_COAP_CODE_NOT_IMPLEMENTED:
codeString = "NotImplemented";
break;
case OT_COAP_CODE_BAD_GATEWAY:
codeString = "BadGateway";
break;
case OT_COAP_CODE_SERVICE_UNAVAILABLE:
codeString = "ServiceUnavailable";
break;
case OT_COAP_CODE_GATEWAY_TIMEOUT:
codeString = "GatewayTimeout";
break;
case OT_COAP_CODE_PROXY_NOT_SUPPORTED:
codeString = "ProxyNotSupported";
break;
default:
codeString = "Unknown";
break;
}
return codeString;
}
#endif // OPENTHREAD_ENABLE_APPLICATION_COAP
} // namespace Coap
} // namespace ot
src/core/coap/coap_header.hpp → src/core/coap/coap_message.hpp
+147 -88
View File
@@ -28,7 +28,7 @@
/**
* @file
* This file includes definitions for generating and processing CoAP headers.
* This file includes definitions for generating and processing CoAP messages.
*/
#ifndef COAP_HEADER_HPP_
@@ -40,6 +40,7 @@
#include <openthread/coap.h>
#include "common/code_utils.hpp"
#include "common/encoding.hpp"
#include "common/message.hpp"
@@ -66,18 +67,19 @@ namespace Coap {
*/
/**
* This class implements CoAP header generation and parsing.
* This class implements CoAP message generation and parsing.
*
*/
class Header : public otCoapHeader
class Message : public ot::Message
{
public:
enum
{
kVersion1 = 1, ///< Version 1
kMinHeaderLength = 4, ///< Minimum header length
kMaxHeaderLength = OT_COAP_HEADER_MAX_LENGTH, ///< Maximum header length
kDefaultTokenLength = 2 ///< Default token length
kVersion1 = 1, ///< Version 1
kMinHeaderLength = 4, ///< Minimum header length
kMaxHeaderLength = 512, ///< Maximum header length
kDefaultTokenLength = 2, ///< Default token length
kTypeOffset = 4, ///< The type offset in the first byte of a coap header
};
/**
@@ -108,16 +110,10 @@ public:
void Init(Type aType, Code aCode);
/**
* This method parses the CoAP header from a message.
*
* @param[in] aMessage A reference to the message.
* @param[in] aMetadataSize A size of metadata appended to the message.
*
* @retval OT_ERROR_NONE Successfully parsed the message.
* @retval OT_ERROR_PARSE Failed to parse the message.
* This method writes header to the message. This must be called before sending the message.
*
*/
otError FromMessage(const Message &aMessage, uint16_t aMetadataSize);
void Finish(void);
/**
* This method returns the Version value.
@@ -125,7 +121,10 @@ public:
* @returns The Version value.
*
*/
uint8_t GetVersion(void) const { return (mHeader.mFields.mVersionTypeToken & kVersionMask) >> kVersionOffset; }
uint8_t GetVersion(void) const
{
return (GetHelpData().mHeader.mVersionTypeToken & kVersionMask) >> kVersionOffset;
}
/**
* This method sets the Version value.
@@ -135,8 +134,8 @@ public:
*/
void SetVersion(uint8_t aVersion)
{
mHeader.mFields.mVersionTypeToken &= ~kVersionMask;
mHeader.mFields.mVersionTypeToken |= aVersion << kVersionOffset;
GetHelpData().mHeader.mVersionTypeToken &= ~kVersionMask;
GetHelpData().mHeader.mVersionTypeToken |= aVersion << kVersionOffset;
}
/**
@@ -145,7 +144,7 @@ public:
* @returns The Type value.
*
*/
Type GetType(void) const { return static_cast<Type>(mHeader.mFields.mVersionTypeToken & kTypeMask); }
Type GetType(void) const { return static_cast<Type>(GetHelpData().mHeader.mVersionTypeToken & kTypeMask); }
/**
* This method sets the Type value.
@@ -155,8 +154,8 @@ public:
*/
void SetType(Type aType)
{
mHeader.mFields.mVersionTypeToken &= ~kTypeMask;
mHeader.mFields.mVersionTypeToken |= aType;
GetHelpData().mHeader.mVersionTypeToken &= ~kTypeMask;
GetHelpData().mHeader.mVersionTypeToken |= aType;
}
/**
@@ -165,7 +164,7 @@ public:
* @returns The Code value.
*
*/
Code GetCode(void) const { return static_cast<Code>(mHeader.mFields.mCode); }
Code GetCode(void) const { return static_cast<Code>(GetHelpData().mHeader.mCode); }
/**
* This method sets the Code value.
@@ -173,7 +172,7 @@ public:
* @param[in] aCode The Code value.
*
*/
void SetCode(Code aCode) { mHeader.mFields.mCode = static_cast<uint8_t>(aCode); }
void SetCode(Code aCode) { GetHelpData().mHeader.mCode = static_cast<uint8_t>(aCode); }
#if OPENTHREAD_ENABLE_APPLICATION_COAP
/**
@@ -191,7 +190,7 @@ public:
* @returns The Message ID value.
*
*/
uint16_t GetMessageId(void) const { return HostSwap16(mHeader.mFields.mMessageId); }
uint16_t GetMessageId(void) const { return HostSwap16(GetHelpData().mHeader.mMessageId); }
/**
* This method sets the Message ID value.
@@ -199,7 +198,7 @@ public:
* @param[in] aMessageId The Message ID value.
*
*/
void SetMessageId(uint16_t aMessageId) { mHeader.mFields.mMessageId = HostSwap16(aMessageId); }
void SetMessageId(uint16_t aMessageId) { GetHelpData().mHeader.mMessageId = HostSwap16(aMessageId); }
/**
* This method returns the Token length.
@@ -209,7 +208,7 @@ public:
*/
uint8_t GetTokenLength(void) const
{
return (mHeader.mFields.mVersionTypeToken & kTokenLengthMask) >> kTokenLengthOffset;
return (GetHelpData().mHeader.mVersionTypeToken & kTokenLengthMask) >> kTokenLengthOffset;
}
/**
@@ -218,7 +217,7 @@ public:
* @returns A pointer to the Token value.
*
*/
const uint8_t *GetToken(void) const { return mHeader.mBytes + kTokenOffset; }
const uint8_t *GetToken(void) const { return GetHelpData().mHeader.mToken; }
/**
* This method sets the Token value and length.
@@ -227,13 +226,7 @@ public:
* @param[in] aTokenLength The Length of @p aToken.
*
*/
void SetToken(const uint8_t *aToken, uint8_t aTokenLength)
{
mHeader.mFields.mVersionTypeToken = (mHeader.mFields.mVersionTypeToken & ~kTokenLengthMask) |
((aTokenLength << kTokenLengthOffset) & kTokenLengthMask);
memcpy(mHeader.mBytes + kTokenOffset, aToken, aTokenLength);
mHeaderLength += aTokenLength;
}
void SetToken(const uint8_t *aToken, uint8_t aTokenLength);
/**
* This method sets the Token length and randomizes its value.
@@ -246,40 +239,18 @@ public:
/**
* This method checks if Tokens in two CoAP headers are equal.
*
* @param[in] aHeader A header to compare.
* @param[in] aMessage A header to compare.
*
* @retval TRUE If two Tokens are equal.
* @retval FALSE If Tokens differ in length or value.
*
*/
bool IsTokenEqual(const Header &aHeader) const
bool IsTokenEqual(const Message &aMessage) const
{
return ((this->GetTokenLength() == aHeader.GetTokenLength()) &&
(memcmp(this->GetToken(), aHeader.GetToken(), this->GetTokenLength()) == 0));
return ((this->GetTokenLength() == aMessage.GetTokenLength()) &&
(memcmp(this->GetToken(), aMessage.GetToken(), this->GetTokenLength()) == 0));
}
/**
* This structure represents a CoAP option.
*
*/
struct Option : public otCoapOption
{
/**
* Protocol Constants
*
*/
enum
{
kOptionDeltaOffset = 4, ///< Delta Offset
kOptionDeltaMask = 0xf << kOptionDeltaOffset, ///< Delta Mask
};
/**
* Option Numbers
*/
typedef otCoapOptionType Type;
};
/**
* This method appends a CoAP option.
*
@@ -290,7 +261,7 @@ public:
* @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.
*
*/
otError AppendOption(const Option &aOption);
otError AppendOption(uint16_t aNumber, uint16_t aLength, const void *aValue);
/**
* This method appends an unsigned integer CoAP option as specified in
@@ -391,43 +362,51 @@ public:
/**
* This method returns a pointer to the first option.
*
* @returns A pointer to the first option.
*
*/
const Option *GetFirstOption(void);
const otCoapOption *GetFirstOption(void);
/**
* This method returns a pointer to the next option.
*
* @returns A pointer to the next option.
*/
const otCoapOption *GetNextOption(void);
/**
* This function fills current option value into @p aValue.
*
* @retval OT_ERROR_NONE Successfully filled value.
* @retval OT_ERROR_NOT_FOUND No more options, aIterator->mNextOptionOffset is set to offset of payload.
*
*/
const Option *GetNextOption(void);
otError GetOptionValue(void *aValue) const;
/**
* This method adds Payload Marker indicating beginning of the payload to the CoAP header.
*
* It also set offset to the start of payload.
*
* @retval OT_ERROR_NONE Payload Marker successfully added.
* @retval OT_ERROR_NO_BUFS Header Payload Marker exceeds the buffer size.
* @retval OT_ERROR_NO_BUFS Message Payload Marker exceeds the buffer size.
*
*/
otError SetPayloadMarker(void);
/**
* This method returns a pointer to the first byte of the header.
* This method returns the offset of the first CoAP option.
*
* @returns A pointer to the first byte of the header.
* @returns The offset of the first CoAP option.
*
*/
const uint8_t *GetBytes(void) const { return mHeader.mBytes; }
uint16_t GetOptionStart(void) const { return kMinHeaderLength + GetTokenLength(); }
/**
* This method returns the header length in bytes.
* This method parses CoAP header and moves offset end of CoAP header.
*
* @returns The header length in bytes.
* @retval OT_ERROR_NONE Successfully parsed CoAP header from the message.
* @retval OT_ERROR_PARSE Failed to parse the CoAP header.
*
*/
uint16_t GetLength(void) const { return mHeaderLength; }
otError ParseHeader(void);
/**
* This method sets a default response header based on request header.
@@ -435,13 +414,13 @@ public:
* @param[in] aRequestHeader Request header to base on.
*
*/
void SetDefaultResponseHeader(const Header &aRequestHeader);
void SetDefaultResponseHeader(const Message &aRequestHeader);
/**
* This method checks if a header is an empty message header.
*
* @retval TRUE Header is an empty message header.
* @retval FALSE Header is not an empty message header.
* @retval TRUE Message is an empty message header.
* @retval FALSE Message is not an empty message header.
*
*/
bool IsEmpty(void) const { return (GetCode() == 0); };
@@ -449,8 +428,8 @@ public:
/**
* This method checks if a header is a request header.
*
* @retval TRUE Header is a request header.
* @retval FALSE Header is not a request header.
* @retval TRUE Message is a request header.
* @retval FALSE Message is not a request header.
*
*/
bool IsRequest(void) const { return (GetCode() >= OT_COAP_CODE_GET && GetCode() <= OT_COAP_CODE_DELETE); };
@@ -458,8 +437,8 @@ public:
/**
* This method checks if a header is a response header.
*
* @retval TRUE Header is a response header.
* @retval FALSE Header is not a response header.
* @retval TRUE Message is a response header.
* @retval FALSE Message is not a response header.
*
*/
bool IsResponse(void) const { return (GetCode() >= OT_COAP_CODE_RESPONSE_MIN); };
@@ -467,8 +446,8 @@ public:
/**
* This method checks if a header is a CON message header.
*
* @retval TRUE Header is a CON message header.
* @retval FALSE Header is not is a CON message header.
* @retval TRUE Message is a CON message header.
* @retval FALSE Message is not is a CON message header.
*
*/
bool IsConfirmable(void) const { return (GetType() == OT_COAP_TYPE_CONFIRMABLE); };
@@ -476,8 +455,8 @@ public:
/**
* This method checks if a header is a NON message header.
*
* @retval TRUE Header is a NON message header.
* @retval FALSE Header is not is a NON message header.
* @retval TRUE Message is a NON message header.
* @retval FALSE Message is not is a NON message header.
*
*/
bool IsNonConfirmable(void) const { return (GetType() == OT_COAP_TYPE_NON_CONFIRMABLE); };
@@ -485,8 +464,8 @@ public:
/**
* This method checks if a header is a ACK message header.
*
* @retval TRUE Header is a ACK message header.
* @retval FALSE Header is not is a ACK message header.
* @retval TRUE Message is a ACK message header.
* @retval FALSE Message is not is a ACK message header.
*
*/
bool IsAck(void) const { return (GetType() == OT_COAP_TYPE_ACKNOWLEDGMENT); };
@@ -494,12 +473,51 @@ public:
/**
* This method checks if a header is a RST message header.
*
* @retval TRUE Header is a RST message header.
* @retval FALSE Header is not is a RST message header.
* @retval TRUE Message is a RST message header.
* @retval FALSE Message is not is a RST message header.
*
*/
bool IsReset(void) const { return (GetType() == OT_COAP_TYPE_RESET); };
/**
* This method creates a copy of this CoAP message.
*
* It allocates the new message from the same message pool as the original one and copies @p aLength octets
* of the payload. The `Type`, `SubType`, `LinkSecurity`, `Offset`, `InterfaceId`, and `Priority` fields on the
* cloned message are also copied from the original one.
*
* @param[in] aLength Number of payload bytes to copy.
*
* @returns A pointer to the message or NULL if insufficient message buffers are available.
*
*/
Message *Clone(uint16_t aLength) const
{
Message *message = static_cast<Message *>(ot::Message::Clone(aLength));
memcpy(&message->GetHelpData(), &GetHelpData(), sizeof(GetHelpData()));
return message;
}
/**
* This method creates a copy of the message.
*
* It allocates the new message from the same message pool as the original one and copies the entire payload. The
* `Type`, `SubType`, `LinkSecurity`, `Offset`, `InterfaceId`, and `Priority` fields on the cloned message are also
* copied from the original one.
*
* @returns A pointer to the message or NULL if insufficient message buffers are available.
*
*/
Message *Clone(void) const { return Clone(GetLength()); };
/**
* This method returns the minimal reserved bytes required for CoAP message.
*
*/
static uint16_t GetHelpDataReserved(void) { return sizeof(HelpData) + kHelpDataAlignment; }
private:
/**
* Protocol Constants (RFC 7252).
@@ -507,6 +525,11 @@ private:
*/
enum
{
kOptionDeltaOffset = 4, ///< Delta Offset
kOptionDeltaMask = 0xf << kOptionDeltaOffset, ///< Delta Mask
kMaxTokenLength = OT_COAP_MAX_TOKEN_LENGTH,
kVersionMask = 0xc0, ///< Version mask as specified (RFC 7252).
kVersionOffset = 6, ///< Version offset as specified (RFC 7252).
@@ -523,7 +546,43 @@ private:
kOption1ByteExtensionOffset = 13, ///< Delta/Length offset as specified (RFC 7252).
kOption2ByteExtensionOffset = 269, ///< Delta/Length offset as specified (RFC 7252).
kHelpDataAlignment = sizeof(uint16_t), ///< Alignment of help data.
};
/**
* This structure represents a CoAP header excluding CoAP options.
*
*/
OT_TOOL_PACKED_BEGIN
struct Header
{
uint8_t mVersionTypeToken; ///< The CoAP Version, Type, and Token Length
uint8_t mCode; ///< The CoAP Code
uint16_t mMessageId; ///< The CoAP Message ID
uint8_t mToken[OT_COAP_MAX_TOKEN_LENGTH]; ///< The CoAP Token
} OT_TOOL_PACKED_END;
/**
* This structure represents a HelpData used by this CoAP message.
*
*/
struct HelpData
{
Header mHeader;
otCoapOption mOption;
uint16_t mNextOptionOffset; ///< The byte offset for the next CoAP Option
uint16_t mOptionLast;
uint16_t mHeaderOffset;
uint16_t mHeaderLength;
};
const HelpData &GetHelpData(void) const
{
return *static_cast<const HelpData *>(otALIGN(mBuffer.mHead.mData, kHelpDataAlignment));
}
HelpData &GetHelpData(void) { return const_cast<HelpData &>(static_cast<const Message *>(this)->GetHelpData()); }
};
/**
src/core/coap/coap_secure.cpp
+10 -8
View File
@@ -90,7 +90,7 @@ otError CoapSecure::Stop(void)
Disconnect();
}
for (Message *message = mTransmitQueue.GetHead(); message != NULL; message = message->GetNext())
for (ot::Message *message = mTransmitQueue.GetHead(); message != NULL; message = message->GetNext())
{
mTransmitQueue.Dequeue(*message);
message->Free();
@@ -227,12 +227,13 @@ otError CoapSecure::Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo
{
OT_UNUSED_VARIABLE(aMessageInfo);
static_cast<Message &>(aMessage).Finish();
mTransmitQueue.Enqueue(aMessage);
mTransmitTask.Post();
return OT_ERROR_NONE;
}
void CoapSecure::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void CoapSecure::Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif &netif = GetNetif();
@@ -294,9 +295,10 @@ void CoapSecure::HandleDtlsReceive(void *aContext, uint8_t *aBuf, uint16_t aLeng
void CoapSecure::HandleDtlsReceive(uint8_t *aBuf, uint16_t aLength)
{
Message *message = NULL;
ot::Message *message = NULL;
VerifyOrExit((message = GetInstance().GetMessagePool().New(Message::kTypeIp6, 0)) != NULL);
VerifyOrExit((message = GetInstance().GetMessagePool().New(Message::kTypeIp6, Message::GetHelpDataReserved())) !=
NULL);
SuccessOrExit(message->Append(aBuf, aLength));
Coap::Receive(*message, mPeerAddress);
@@ -316,8 +318,8 @@ otError CoapSecure::HandleDtlsSend(void *aContext, const uint8_t *aBuf, uint16_t
otError CoapSecure::HandleDtlsSend(const uint8_t *aBuf, uint16_t aLength, uint8_t aMessageSubType)
{
otError error = OT_ERROR_NONE;
Message *message = NULL;
otError error = OT_ERROR_NONE;
ot::Message *message = NULL;
VerifyOrExit((message = mSocket.NewMessage(0)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetSubType(aMessageSubType);
@@ -357,8 +359,8 @@ void CoapSecure::HandleTransmit(Tasklet &aTasklet)
void CoapSecure::HandleTransmit(void)
{
otError error = OT_ERROR_NONE;
Message *message = mTransmitQueue.GetHead();
otError error = OT_ERROR_NONE;
ot::Message *message = mTransmitQueue.GetHead();
VerifyOrExit(message != NULL);
mTransmitQueue.Dequeue(*message);
src/core/coap/coap_secure.hpp
+2 -2
View File
@@ -65,7 +65,7 @@ public:
* @param[in] aMessageInfo A reference to the message info associated with @p aMessage.
*
*/
typedef otError (*TransportCallback)(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
typedef otError (*TransportCallback)(void *aContext, ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
/**
* This constructor initializes the object.
@@ -307,7 +307,7 @@ public:
* @param[in] aMessageInfo A reference to the message info associated with @p aMessage.
*
*/
virtual void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
virtual void Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
/**
* This method returns the DTLS session's peer address.
src/core/common/code_utils.hpp
+11
View File
@@ -48,6 +48,17 @@
*/
#define OT_ARRAY_LENGTH(aArray) (sizeof(aArray) / sizeof(aArray[0]))
/**
* This macro returns a pointer aligned by @p aAlignment.
*
* @param[in] aPointer A pointer to contiguous space.
* @param[in] aAlignment The desired alignment.
*
* @returns The aligned pointer.
*
*/
#define otALIGN(aPointer, aAlignment) ((void *)(((uintptr_t)(aPointer) + (aAlignment)-1U) & ~((aAlignment)-1U)))
// Calculates the aligned variable size.
#define otALIGNED_VAR_SIZE(size, align_type) (((size) + (sizeof(align_type) - 1)) / sizeof(align_type))
src/core/common/message.hpp
+1
View File
@@ -183,6 +183,7 @@ private:
kHeadBufferDataSize = kBufferDataSize - sizeof(struct MessageInfo),
};
protected:
union
{
struct
src/core/meshcop/announce_begin_client.cpp
+7 -10
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -62,24 +62,21 @@ otError AnnounceBeginClient::SendRequest(uint32_t aChannelMask,
const Ip6::Address &aAddress)
{
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::CommissionerSessionIdTlv sessionId;
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::CountTlv count;
MeshCoP::PeriodTlv period;
Ip6::MessageInfo messageInfo;
Message * message = NULL;
Coap::Message * message = NULL;
VerifyOrExit(GetNetif().GetCommissioner().IsActive(), error = OT_ERROR_INVALID_STATE);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
header.Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ANNOUNCE_BEGIN);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap(), header)) != NULL,
error = OT_ERROR_NO_BUFS);
message->Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_ANNOUNCE_BEGIN);
message->SetPayloadMarker();
sessionId.Init();
sessionId.SetCommissionerSessionId(GetNetif().GetCommissioner().GetSessionId());
src/core/meshcop/border_agent.cpp
+143 -138
View File
@@ -35,7 +35,7 @@
#include "border_agent.hpp"
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/instance.hpp"
#include "common/logging.hpp"
#include "common/new.hpp"
@@ -63,15 +63,15 @@ public:
* @param[in] aSeparate Whether this original request expects separate response.
*
*/
ForwardContext(BorderAgent &aBorderAgent, const Coap::Header &aHeader, bool aPetition, bool aSeparate)
ForwardContext(BorderAgent &aBorderAgent, const Coap::Message &aMessage, bool aPetition, bool aSeparate)
: mBorderAgent(aBorderAgent)
, mMessageId(aHeader.GetMessageId())
, mMessageId(aMessage.GetMessageId())
, mPetition(aPetition)
, mSeparate(aSeparate)
, mTokenLength(aHeader.GetTokenLength())
, mType(aHeader.GetType() >> kTypeOffset)
, mTokenLength(aMessage.GetTokenLength())
, mType(aMessage.GetType() >> Coap::Message::kTypeOffset)
{
memcpy(mToken, aHeader.GetToken(), mTokenLength);
memcpy(mToken, aMessage.GetToken(), mTokenLength);
}
/**
@@ -106,39 +106,38 @@ public:
* @param[in] aCode The response code to fill in the response header.
*
*/
void ToHeader(Coap::Header &aHeader, Coap::Header::Code aCode)
void ToHeader(Coap::Message &aMessage, Coap::Message::Code aCode)
{
if (mType == (OT_COAP_TYPE_NON_CONFIRMABLE >> kTypeOffset) || mSeparate)
if (mType == (OT_COAP_TYPE_NON_CONFIRMABLE >> Coap::Message::kTypeOffset) || mSeparate)
{
aHeader.Init(OT_COAP_TYPE_NON_CONFIRMABLE, aCode);
aMessage.Init(OT_COAP_TYPE_NON_CONFIRMABLE, aCode);
}
else
{
aHeader.Init(OT_COAP_TYPE_ACKNOWLEDGMENT, aCode);
aMessage.Init(OT_COAP_TYPE_ACKNOWLEDGMENT, aCode);
}
aHeader.SetMessageId(mSeparate ? 0 : mMessageId);
aHeader.SetToken(mToken, mTokenLength);
aMessage.SetMessageId(mSeparate ? 0 : mMessageId);
aMessage.SetToken(mToken, mTokenLength);
}
private:
enum
{
kTypeOffset = 4, ///< The type offset in the first byte of coap header
kMaxTokenLength = OT_COAP_MAX_TOKEN_LENGTH, ///< The max token size
};
BorderAgent &mBorderAgent;
uint16_t mMessageId; ///< The CoAP Message ID of the original request.
bool mPetition : 1; ///< Whether the forwarding request is leader petition.
bool mSeparate : 1; ///< Whether the original request expects separate response.
uint8_t mTokenLength : 4; ///< The CoAP Token Length of the original request.
uint8_t mType : 2; ///< The CoAP Type of the original request.
uint8_t mToken[OT_COAP_MAX_TOKEN_LENGTH]; ///< The CoAP Token of the original request.
uint16_t mMessageId; ///< The CoAP Message ID of the original request.
bool mPetition : 1; ///< Whether the forwarding request is leader petition.
bool mSeparate : 1; ///< Whether the original request expects separate response.
uint8_t mTokenLength : 4; ///< The CoAP Token Length of the original request.
uint8_t mType : 2; ///< The CoAP Type of the original request.
uint8_t mToken[kMaxTokenLength]; ///< The CoAP Token of the original request.
};
static Coap::Header::Code CoapCodeFromError(otError aError)
static Coap::Message::Code CoapCodeFromError(otError aError)
{
Coap::Header::Code code;
Coap::Message::Code code;
switch (aError)
{
@@ -158,18 +157,16 @@ static Coap::Header::Code CoapCodeFromError(otError aError)
return code;
}
void BorderAgent::SendErrorMessage(const Coap::Header &aHeader)
static void SendErrorMessage(Coap::CoapSecure &aCoapSecure, ForwardContext &aForwardContext)
{
otError error = OT_ERROR_NONE;
Message * message = NULL;
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message *message = NULL;
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure(), aHeader)) != NULL, error = OT_ERROR_NO_BUFS);
SuccessOrExit(error = netif.GetCoapSecure().SendMessage(*message, netif.GetCoapSecure().GetPeerMessageInfo()));
VerifyOrExit((message = NewMeshCoPMessage(aCoapSecure)) != NULL, error = OT_ERROR_NO_BUFS);
aForwardContext.ToHeader(*message, CoapCodeFromError(error));
SuccessOrExit(error = aCoapSecure.SendMessage(*message, aCoapSecure.GetPeerMessageInfo()));
exit:
if (error != OT_ERROR_NONE)
{
if (message != NULL)
@@ -177,32 +174,65 @@ exit:
message->Free();
}
otLogWarnMeshCoP("Failed to send CoAP message: %s", otThreadErrorToString(error));
otLogWarnMeshCoP("Failed to send error CoAP message: %s", otThreadErrorToString(error));
}
}
static void SendErrorMessage(Coap::CoapSecure &aCoapSecure, const Coap::Message &aRequest, bool aSeparate)
{
otError error = OT_ERROR_NONE;
Coap::Message *message = NULL;
VerifyOrExit((message = NewMeshCoPMessage(aCoapSecure)) != NULL, error = OT_ERROR_NO_BUFS);
if (aRequest.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE || aSeparate)
{
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, CoapCodeFromError(error));
}
else
{
message->Init(OT_COAP_TYPE_ACKNOWLEDGMENT, CoapCodeFromError(error));
}
message->SetMessageId(aSeparate ? 0 : aRequest.GetMessageId());
message->SetToken(aRequest.GetToken(), aRequest.GetTokenLength());
SuccessOrExit(error = aCoapSecure.SendMessage(*message, aCoapSecure.GetPeerMessageInfo()));
exit:
if (error != OT_ERROR_NONE)
{
if (message != NULL)
{
message->Free();
}
otLogWarnMeshCoP("Failed to send error CoAP message: %s", otThreadErrorToString(error));
}
}
void BorderAgent::HandleCoapResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
OT_UNUSED_VARIABLE(aMessageInfo);
ForwardContext &forwardContext = *static_cast<ForwardContext *>(aContext);
BorderAgent & borderAgent = forwardContext.GetBorderAgent();
ThreadNetif & netif = borderAgent.GetNetif();
const Message * message = static_cast<const Message *>(aMessage);
Coap::Header header;
otError error;
ForwardContext & forwardContext = *static_cast<ForwardContext *>(aContext);
BorderAgent & borderAgent = forwardContext.GetBorderAgent();
ThreadNetif & netif = borderAgent.GetNetif();
const Coap::Message *response = static_cast<const Coap::Message *>(aMessage);
Coap::Message * message = NULL;
otError error;
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure())) != NULL, error = OT_ERROR_NO_BUFS);
SuccessOrExit(error = aResult);
if (forwardContext.IsPetition())
{
StateTlv stateTlv;
SuccessOrExit(error = Tlv::GetTlv(*message, Tlv::kState, sizeof(stateTlv), stateTlv));
SuccessOrExit(error = Tlv::GetTlv(*response, Tlv::kState, sizeof(stateTlv), stateTlv));
VerifyOrExit(stateTlv.IsValid(), error = OT_ERROR_PARSE);
if (stateTlv.GetState() == StateTlv::kAccept)
@@ -210,7 +240,7 @@ void BorderAgent::HandleCoapResponse(void * aContext,
CommissionerSessionIdTlv sessionIdTlv;
SuccessOrExit(error =
Tlv::GetTlv(*message, Tlv::kCommissionerSessionId, sizeof(sessionIdTlv), sessionIdTlv));
Tlv::GetTlv(*response, Tlv::kCommissionerSessionId, sizeof(sessionIdTlv), sessionIdTlv));
VerifyOrExit(sessionIdTlv.IsValid(), error = OT_ERROR_PARSE);
netif.GetMle().GetCommissionerAloc(borderAgent.mCommissionerAloc.GetAddress(),
@@ -220,80 +250,76 @@ void BorderAgent::HandleCoapResponse(void * aContext,
}
}
forwardContext.ToHeader(header, static_cast<Coap::Header *>(aHeader)->GetCode());
forwardContext.ToHeader(*message, response->GetCode());
if (message->GetLength() - message->GetOffset() > 0)
if (response->GetLength() - response->GetOffset() > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
SuccessOrExit(error = borderAgent.ForwardToCommissioner(header, *message));
SuccessOrExit(error = borderAgent.ForwardToCommissioner(*message, *response));
exit:
if (error != OT_ERROR_NONE)
{
if (message != NULL)
{
message->Free();
}
otLogWarnMeshCoP("Commissioner request[%hu] failed: %s", forwardContext.GetMessageId(),
otThreadErrorToString(aResult));
forwardContext.ToHeader(header, CoapCodeFromError(error));
borderAgent.SendErrorMessage(header);
otThreadErrorToString(error));
SendErrorMessage(netif.GetCoapSecure(), forwardContext);
}
netif.GetInstance().GetHeap().Free(&forwardContext);
borderAgent.GetInstance().GetHeap().Free(&forwardContext);
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mCommissionerPetition>(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
static_cast<BorderAgent *>(aContext)->ForwardToLeader(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo), OT_URI_PATH_LEADER_PETITION, true, true);
static_cast<BorderAgent *>(aContext)->ForwardToLeader(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo),
OT_URI_PATH_LEADER_PETITION, true, true);
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mCommissionerKeepAlive>(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
static_cast<BorderAgent *>(aContext)->HandleKeepAlive(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<BorderAgent *>(aContext)->HandleKeepAlive(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mRelayTransmit>(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
static_cast<BorderAgent *>(aContext)->HandleRelayTransmit(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage));
static_cast<BorderAgent *>(aContext)->HandleRelayTransmit(*static_cast<Coap::Message *>(aMessage));
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mRelayReceive>(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
static_cast<BorderAgent *>(aContext)->HandleRelayReceive(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage));
static_cast<BorderAgent *>(aContext)->HandleRelayReceive(*static_cast<Coap::Message *>(aMessage));
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mProxyTransmit>(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
static_cast<BorderAgent *>(aContext)->HandleProxyTransmit(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage));
static_cast<BorderAgent *>(aContext)->HandleProxyTransmit(*static_cast<Coap::Message *>(aMessage));
}
BorderAgent::BorderAgent(Instance &aInstance)
@@ -324,10 +350,8 @@ BorderAgent::BorderAgent(Instance &aInstance)
mCommissionerAloc.mScopeOverrideValid = true;
}
void BorderAgent::HandleProxyTransmit(const Coap::Header &aHeader, const Message &aMessage)
void BorderAgent::HandleProxyTransmit(const Coap::Message &aMessage)
{
OT_UNUSED_VARIABLE(aHeader);
Message * message = NULL;
Ip6::MessageInfo messageInfo;
uint16_t offset;
@@ -373,21 +397,20 @@ exit:
bool BorderAgent::HandleUdpReceive(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Coap::Header header;
otError error;
Message * message = NULL;
ThreadNetif &netif = GetNetif();
otError error;
Coap::Message *message = NULL;
ThreadNetif & netif = GetNetif();
VerifyOrExit(aMessageInfo.GetSockAddr() == mCommissionerAloc.GetAddress(),
error = OT_ERROR_DESTINATION_ADDRESS_FILTERED);
VerifyOrExit(aMessage.GetLength() > 0, error = OT_ERROR_NONE);
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_PROXY_RX);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_PROXY_RX);
message->SetPayloadMarker();
{
UdpEncapsulationTlv tlv;
@@ -427,41 +450,44 @@ exit:
return error != OT_ERROR_DESTINATION_ADDRESS_FILTERED;
}
void BorderAgent::HandleRelayReceive(const Coap::Header &aHeader, const Message &aMessage)
void BorderAgent::HandleRelayReceive(const Coap::Message &aMessage)
{
Coap::Header header;
Coap::Message *message = NULL;
otError error;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
VerifyOrExit((message = NewMeshCoPMessage(GetNetif().GetCoapSecure())) != NULL, error = OT_ERROR_NO_BUFS);
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_RELAY_RX);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_RELAY_RX);
if (aMessage.GetLength() - aMessage.GetOffset() > 0)
if (aMessage.GetLength() > aMessage.GetOffset())
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
SuccessOrExit(ForwardToCommissioner(header, aMessage));
SuccessOrExit(error = ForwardToCommissioner(*message, aMessage));
otLogInfoMeshCoP("Sent to commissioner on %s", OT_URI_PATH_RELAY_RX);
exit:
return;
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
}
otError BorderAgent::ForwardToCommissioner(const Coap::Header &aHeader, const Message &aMessage)
otError BorderAgent::ForwardToCommissioner(Coap::Message &aNewMessage, const Message &aMessage)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Message * message = NULL;
uint16_t offset = 0;
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
uint16_t offset = 0;
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure(), aHeader)) != NULL, error = OT_ERROR_NO_BUFS);
offset = aNewMessage.GetLength();
SuccessOrExit(error = aNewMessage.SetLength(offset + aMessage.GetLength() - aMessage.GetOffset()));
aMessage.CopyTo(aMessage.GetOffset(), offset, aMessage.GetLength() - aMessage.GetOffset(), aNewMessage);
offset = message->GetLength();
SuccessOrExit(error = message->SetLength(offset + aMessage.GetLength() - aMessage.GetOffset()));
aMessage.CopyTo(aMessage.GetOffset(), offset, aMessage.GetLength() - aMessage.GetOffset(), *message);
SuccessOrExit(error = netif.GetCoapSecure().SendMessage(*message, netif.GetCoapSecure().GetPeerMessageInfo()));
SuccessOrExit(error = netif.GetCoapSecure().SendMessage(aNewMessage, netif.GetCoapSecure().GetPeerMessageInfo()));
otLogInfoMeshCoP("Sent to commissioner");
@@ -469,22 +495,16 @@ exit:
if (error != OT_ERROR_NONE)
{
otLogWarnMeshCoP("Failed to send to commissioner: %s", otThreadErrorToString(error));
if (message != NULL)
{
message->Free();
}
}
return error;
}
void BorderAgent::HandleKeepAlive(const Coap::Header & aHeader,
const Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void BorderAgent::HandleKeepAlive(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
otError error;
error = ForwardToLeader(aHeader, aMessage, aMessageInfo, OT_URI_PATH_LEADER_KEEP_ALIVE, false, true);
error = ForwardToLeader(aMessage, aMessageInfo, OT_URI_PATH_LEADER_KEEP_ALIVE, false, true);
if (error == OT_ERROR_NONE)
{
@@ -492,27 +512,26 @@ void BorderAgent::HandleKeepAlive(const Coap::Header & aHeader,
}
}
void BorderAgent::HandleRelayTransmit(const Coap::Header &aHeader, const Message &aMessage)
void BorderAgent::HandleRelayTransmit(const Coap::Message &aMessage)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
JoinerRouterLocatorTlv joinerRouterRloc;
Message * message = NULL;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
Coap::Header header;
uint16_t offset = 0;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(error = Tlv::GetTlv(aMessage, Tlv::kJoinerRouterLocator, sizeof(joinerRouterRloc), joinerRouterRloc));
VerifyOrExit(joinerRouterRloc.IsValid(), error = OT_ERROR_PARSE);
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_RELAY_TX);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_RELAY_TX);
message->SetPayloadMarker();
offset = message->GetLength();
SuccessOrExit(error = message->SetLength(offset + aMessage.GetLength() - aMessage.GetOffset()));
@@ -540,8 +559,7 @@ exit:
}
}
otError BorderAgent::ForwardToLeader(const Coap::Header & aHeader,
const Message & aMessage,
otError BorderAgent::ForwardToLeader(const Coap::Message & aMessage,
const Ip6::MessageInfo &aMessageInfo,
const char * aPath,
bool aPetition,
@@ -551,32 +569,31 @@ otError BorderAgent::ForwardToLeader(const Coap::Header & aHeader,
otError error = OT_ERROR_NONE;
ForwardContext * forwardContext = NULL;
Ip6::MessageInfo messageInfo;
Coap::Header header;
Message * message = NULL;
Coap::Message * message = NULL;
uint16_t offset = 0;
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
if (aSeparate)
{
SuccessOrExit(error = netif.GetCoapSecure().SendAck(aHeader, aMessageInfo));
SuccessOrExit(error = netif.GetCoapSecure().SendAck(aMessage, aMessageInfo));
}
forwardContext = static_cast<ForwardContext *>(GetInstance().GetHeap().CAlloc(1, sizeof(ForwardContext)));
VerifyOrExit(forwardContext != NULL, error = OT_ERROR_NO_BUFS);
forwardContext = new (forwardContext) ForwardContext(*this, aHeader, aPetition, aSeparate);
forwardContext = new (forwardContext) ForwardContext(*this, aMessage, aPetition, aSeparate);
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(aPath);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(aPath);
// Payload of c/cg may be empty
if (aMessage.GetLength() - aMessage.GetOffset() > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
offset = message->GetLength();
SuccessOrExit(error = message->SetLength(offset + aMessage.GetLength() - aMessage.GetOffset()));
aMessage.CopyTo(aMessage.GetOffset(), offset, aMessage.GetLength() - aMessage.GetOffset(), *message);
@@ -596,8 +613,6 @@ otError BorderAgent::ForwardToLeader(const Coap::Header & aHeader,
exit:
if (error != OT_ERROR_NONE)
{
otLogWarnMeshCoP("Failed to forward to leader: %s", otThreadErrorToString(error));
if (forwardContext != NULL)
{
GetInstance().GetHeap().Free(forwardContext);
@@ -608,19 +623,9 @@ exit:
message->Free();
}
if (aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE || aSeparate)
{
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, CoapCodeFromError(error));
}
else
{
header.Init(OT_COAP_TYPE_ACKNOWLEDGMENT, CoapCodeFromError(error));
}
otLogWarnMeshCoP("Failed to forward to leader: %s", otThreadErrorToString(error));
header.SetMessageId(aSeparate ? 0 : aHeader.GetMessageId());
header.SetToken(aHeader.GetToken(), aHeader.GetTokenLength());
SendErrorMessage(header);
SendErrorMessage(netif.GetCoapSecure(), aMessage, aSeparate);
}
return error;
src/core/meshcop/border_agent.hpp
+12 -19
View File
@@ -92,14 +92,10 @@ private:
otError StartCoaps(void);
template <Coap::Resource BorderAgent::*aResource>
static void HandleRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<BorderAgent *>(aContext)->ForwardToLeader(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo),
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo),
(static_cast<BorderAgent *>(aContext)->*aResource).GetUriPath(), false, false);
}
@@ -107,23 +103,20 @@ private:
void HandleTimeout(void);
static void HandleCoapResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void SendErrorMessage(const Coap::Header &aHeader);
otError ForwardToLeader(const Coap::Header & aHeader,
const Message & aMessage,
const Ip6::MessageInfo &aMessageInfo,
const char * aPath,
bool aPetition,
bool aSeparate);
otError ForwardToCommissioner(const Coap::Header &aHeader, const Message &aMessage);
void HandleKeepAlive(const Coap::Header &aHeader, const Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleRelayTransmit(const Coap::Header &aHeader, const Message &aMessage);
void HandleRelayReceive(const Coap::Header &aHeader, const Message &aMessage);
void HandleProxyTransmit(const Coap::Header &aHeader, const Message &aMessage);
otError ForwardToLeader(const Coap::Message & aMessage,
const Ip6::MessageInfo &aMessageInfo,
const char * aPath,
bool aPetition,
bool aSeparate);
otError ForwardToCommissioner(Coap::Message &aForwardMessage, const Message &aMessage);
void HandleKeepAlive(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleRelayTransmit(const Coap::Message &aMessage);
void HandleRelayReceive(const Coap::Message &aMessage);
void HandleProxyTransmit(const Coap::Message &aMessage);
static bool HandleUdpReceive(void *aContext, const otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
return static_cast<BorderAgent *>(aContext)->HandleUdpReceive(
src/core/meshcop/commissioner.cpp
+76 -110
View File
@@ -40,7 +40,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/encoding.hpp"
#include "common/instance.hpp"
#include "common/logging.hpp"
@@ -426,22 +426,21 @@ otError Commissioner::SendMgmtCommissionerGetRequest(const uint8_t *aTlvs, uint8
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
MeshCoP::Tlv tlv;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_COMMISSIONER_GET);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_COMMISSIONER_GET);
if (aLength > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
if (aLength > 0)
{
tlv.SetType(MeshCoP::Tlv::kGet);
@@ -469,25 +468,21 @@ exit:
}
void Commissioner::HandleMgmtCommissionerGetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<Commissioner *>(aContext)->HandleMgmtCommissionerGetResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void Commissioner::HandleMgmtCommissionerGetResponse(Coap::Header * aHeader,
Message * aMessage,
void Commissioner::HandleMgmtCommissionerGetResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
OT_UNUSED_VARIABLE(aMessage);
OT_UNUSED_VARIABLE(aMessageInfo);
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader->GetCode() == OT_COAP_CODE_CHANGED);
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage->GetCode() == OT_COAP_CODE_CHANGED);
otLogInfoMeshCoP("received MGMT_COMMISSIONER_GET response");
exit:
@@ -500,16 +495,15 @@ otError Commissioner::SendMgmtCommissionerSetRequest(const otCommissioningDatase
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_COMMISSIONER_SET);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_COMMISSIONER_SET);
message->SetPayloadMarker();
if (aDataset.mIsLocatorSet)
{
@@ -549,7 +543,7 @@ otError Commissioner::SendMgmtCommissionerSetRequest(const otCommissioningDatase
SuccessOrExit(error = message->Append(aTlvs, aLength));
}
if (message->GetLength() == header.GetLength())
if (message->GetLength() == message->GetOffset())
{
// no payload, remove coap payload marker
message->SetLength(message->GetLength() - 1);
@@ -574,25 +568,21 @@ exit:
}
void Commissioner::HandleMgmtCommissionerSetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<Commissioner *>(aContext)->HandleMgmtCommissionerSetResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void Commissioner::HandleMgmtCommissionerSetResponse(Coap::Header * aHeader,
Message * aMessage,
void Commissioner::HandleMgmtCommissionerSetResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
OT_UNUSED_VARIABLE(aMessage);
OT_UNUSED_VARIABLE(aMessageInfo);
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader->GetCode() == OT_COAP_CODE_CHANGED);
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage->GetCode() == OT_COAP_CODE_CHANGED);
otLogInfoMeshCoP("received MGMT_COMMISSIONER_SET response");
exit:
@@ -601,21 +591,20 @@ exit:
otError Commissioner::SendPetition(void)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message = NULL;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
CommissionerIdTlv commissionerId;
mTransmitAttempts++;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_LEADER_PETITION);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_LEADER_PETITION);
message->SetPayloadMarker();
commissionerId.Init();
commissionerId.SetCommissionerId("OpenThread Commissioner");
@@ -641,18 +630,15 @@ exit:
}
void Commissioner::HandleLeaderPetitionResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<Commissioner *>(aContext)->HandleLeaderPetitionResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void Commissioner::HandleLeaderPetitionResponse(Coap::Header * aHeader,
Message * aMessage,
void Commissioner::HandleLeaderPetitionResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
@@ -664,7 +650,7 @@ void Commissioner::HandleLeaderPetitionResponse(Coap::Header * aHeader,
bool retransmit = false;
VerifyOrExit(mState == OT_COMMISSIONER_STATE_PETITION, mState = OT_COMMISSIONER_STATE_DISABLED);
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader->GetCode() == OT_COAP_CODE_CHANGED, retransmit = true);
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage->GetCode() == OT_COAP_CODE_CHANGED, retransmit = true);
otLogInfoMeshCoP("received Leader Petition response");
@@ -705,20 +691,19 @@ exit:
otError Commissioner::SendKeepAlive(void)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message = NULL;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
StateTlv state;
CommissionerSessionIdTlv sessionId;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_LEADER_KEEP_ALIVE);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_LEADER_KEEP_ALIVE);
message->SetPayloadMarker();
state.Init();
state.SetState(mState == OT_COMMISSIONER_STATE_ACTIVE ? StateTlv::kAccept : StateTlv::kReject);
@@ -747,18 +732,15 @@ exit:
}
void Commissioner::HandleLeaderKeepAliveResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<Commissioner *>(aContext)->HandleLeaderKeepAliveResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void Commissioner::HandleLeaderKeepAliveResponse(Coap::Header * aHeader,
Message * aMessage,
void Commissioner::HandleLeaderKeepAliveResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
@@ -767,7 +749,7 @@ void Commissioner::HandleLeaderKeepAliveResponse(Coap::Header * aHeader
StateTlv state;
VerifyOrExit(mState == OT_COMMISSIONER_STATE_ACTIVE, mState = OT_COMMISSIONER_STATE_DISABLED);
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader->GetCode() == OT_COAP_CODE_CHANGED,
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage->GetCode() == OT_COAP_CODE_CHANGED,
mState = OT_COMMISSIONER_STATE_DISABLED);
otLogInfoMeshCoP("received Leader keep-alive response");
@@ -788,17 +770,13 @@ exit:
}
}
void Commissioner::HandleRelayReceive(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Commissioner::HandleRelayReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Commissioner *>(aContext)->HandleRelayReceive(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Commissioner *>(aContext)->HandleRelayReceive(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Commissioner::HandleRelayReceive(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Commissioner::HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
@@ -815,7 +793,7 @@ void Commissioner::HandleRelayReceive(Coap::Header &aHeader, Message &aMessage,
VerifyOrExit(mState == OT_COMMISSIONER_STATE_ACTIVE, error = OT_ERROR_INVALID_STATE);
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(error = Tlv::GetTlv(aMessage, Tlv::kJoinerUdpPort, sizeof(joinerPort), joinerPort));
VerifyOrExit(joinerPort.IsValid(), error = OT_ERROR_PARSE);
@@ -883,25 +861,19 @@ exit:
return;
}
void Commissioner::HandleDatasetChanged(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Commissioner::HandleDatasetChanged(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Commissioner *>(aContext)->HandleDatasetChanged(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Commissioner *>(aContext)->HandleDatasetChanged(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Commissioner::HandleDatasetChanged(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Commissioner::HandleDatasetChanged(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessage);
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
otLogInfoMeshCoP("received dataset changed");
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, aMessageInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, aMessageInfo));
otLogInfoMeshCoP("sent dataset changed acknowledgment");
@@ -909,17 +881,13 @@ exit:
return;
}
void Commissioner::HandleJoinerFinalize(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Commissioner::HandleJoinerFinalize(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Commissioner *>(aContext)->HandleJoinerFinalize(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Commissioner *>(aContext)->HandleJoinerFinalize(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Commissioner::HandleJoinerFinalize(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Commissioner::HandleJoinerFinalize(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
@@ -939,33 +907,32 @@ void Commissioner::HandleJoinerFinalize(Coap::Header &aHeader, Message &aMessage
}
#if OPENTHREAD_ENABLE_CERT_LOG
uint8_t buf[OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE];
VerifyOrExit(aMessage.GetLength() <= sizeof(buf));
aMessage.Read(aHeader.GetLength(), aMessage.GetLength() - aHeader.GetLength(), buf);
otDumpCertMeshCoP("[THCI] direction=recv | type=JOIN_FIN.req |", buf, aMessage.GetLength() - aHeader.GetLength());
if (aMessage.GetLength() <= OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE)
{
uint8_t buf[OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE];
exit:
aMessage.Read(aMessage.GetOffset(), aMessage.GetLength() - aMessage.GetOffset(), buf);
otDumpCertMeshCoP("[THCI] direction=recv | type=JOIN_FIN.req |", buf,
aMessage.GetLength() - aMessage.GetOffset());
}
#endif
SendJoinFinalizeResponse(aHeader, state);
SendJoinFinalizeResponse(aMessage, state);
}
void Commissioner::SendJoinFinalizeResponse(const Coap::Header &aRequestHeader, StateTlv::State aState)
void Commissioner::SendJoinFinalizeResponse(const Coap::Message &aRequest, StateTlv::State aState)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
Ip6::MessageInfo joinerMessageInfo;
MeshCoP::StateTlv stateTlv;
Message * message;
Coap::Message * message;
Mac::ExtAddress extAddr;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure(), responseHeader)) != NULL,
error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure())) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
message->SetSubType(Message::kSubTypeJoinerFinalizeResponse);
stateTlv.Init();
@@ -978,10 +945,10 @@ void Commissioner::SendJoinFinalizeResponse(const Coap::Header &aRequestHeader,
#if OPENTHREAD_ENABLE_CERT_LOG
uint8_t buf[OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE];
VerifyOrExit(message->GetLength() <= sizeof(buf));
message->Read(responseHeader.GetLength(), message->GetLength() - responseHeader.GetLength(), buf);
otDumpCertMeshCoP("[THCI] direction=send | type=JOIN_FIN.rsp |", buf,
message->GetLength() - responseHeader.GetLength());
message->Read(message->GetOffset(), message->GetLength() - message->GetOffset(), buf);
otDumpCertMeshCoP("[THCI] direction=send | type=JOIN_FIN.rsp |", buf, message->GetLength() - message->GetOffset());
#endif
SuccessOrExit(error = netif.GetCoapSecure().SendMessage(*message, joinerMessageInfo));
@@ -1011,20 +978,19 @@ otError Commissioner::SendRelayTransmit(Message &aMessage, const Ip6::MessageInf
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
JoinerUdpPortTlv udpPort;
JoinerIidTlv iid;
JoinerRouterLocatorTlv rloc;
ExtendedTlv tlv;
Message * message;
Coap::Message * message;
uint16_t offset;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_RELAY_TX);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_RELAY_TX);
message->SetPayloadMarker();
udpPort.Init();
udpPort.SetUdpPort(mJoinerPort);
src/core/meshcop/commissioner.hpp
+11 -32
View File
@@ -261,61 +261,40 @@ private:
void UpdateJoinerExpirationTimer(void);
static void HandleMgmtCommissionerSetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleMgmtCommissionerSetResponse(Coap::Header * aHeader,
Message * aMessage,
void HandleMgmtCommissionerSetResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
static void HandleMgmtCommissionerGetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleMgmtCommissionerGetResponse(Coap::Header * aHeader,
Message * aMessage,
void HandleMgmtCommissionerGetResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
static void HandleLeaderPetitionResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleLeaderPetitionResponse(Coap::Header * aHeader,
Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
void HandleLeaderPetitionResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, otError aResult);
static void HandleLeaderKeepAliveResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleLeaderKeepAliveResponse(Coap::Header * aHeader,
Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
void HandleLeaderKeepAliveResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, otError aResult);
static void HandleRelayReceive(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleRelayReceive(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleRelayReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDatasetChanged(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleDatasetChanged(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDatasetChanged(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleDatasetChanged(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleJoinerFinalize(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleJoinerFinalize(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleJoinerFinalize(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleJoinerFinalize(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void SendJoinFinalizeResponse(const Coap::Header &aRequestHeader, StateTlv::State aState);
void SendJoinFinalizeResponse(const Coap::Message &aRequest, StateTlv::State aState);
static otError SendRelayTransmit(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendRelayTransmit(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
src/core/meshcop/dataset_manager.cpp
+40 -54
View File
@@ -271,17 +271,16 @@ otError DatasetManager::Register(void)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
Dataset dataset(mLocal.GetType());
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(mUriSet);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(mUriSet);
message->SetPayloadMarker();
mLocal.Get(dataset);
SuccessOrExit(error = message->Append(dataset.GetBytes(), dataset.GetSize()));
@@ -303,9 +302,7 @@ exit:
return error;
}
void DatasetManager::Get(const Coap::Header & aHeader,
const Message & aMessage,
const Ip6::MessageInfo &aMessageInfo) const
void DatasetManager::Get(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
Tlv tlv;
uint16_t offset = aMessage.GetOffset();
@@ -345,26 +342,25 @@ void DatasetManager::Get(const Coap::Header & aHeader,
}
}
SendGetResponse(aHeader, aMessageInfo, tlvs, length);
SendGetResponse(aMessage, aMessageInfo, tlvs, length);
}
void DatasetManager::SendGetResponse(const Coap::Header & aRequestHeader,
void DatasetManager::SendGetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
uint8_t * aTlvs,
uint8_t aLength) const
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
Message * message;
Dataset dataset(mLocal.GetType());
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message *message;
Dataset dataset(mLocal.GetType());
mLocal.Get(dataset);
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
if (aLength == 0)
{
@@ -401,7 +397,7 @@ void DatasetManager::SendGetResponse(const Coap::Header & aRequestHeader,
}
}
if (message->GetLength() == responseHeader.GetLength())
if (message->GetLength() == message->GetOffset())
{
// no payload, remove coap payload marker
message->SetLength(message->GetLength() - 1);
@@ -423,16 +419,15 @@ otError DatasetManager::SendSetRequest(const otOperationalDataset &aDataset, con
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(mUriSet);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(mUriSet);
message->SetPayloadMarker();
#if OPENTHREAD_ENABLE_COMMISSIONER && OPENTHREAD_FTD
@@ -555,7 +550,7 @@ otError DatasetManager::SendSetRequest(const otOperationalDataset &aDataset, con
SuccessOrExit(error = message->Append(aTlvs, aLength));
}
if (message->GetLength() == header.GetLength())
if (message->GetLength() == message->GetOffset())
{
// no payload, remove coap payload marker
message->SetLength(message->GetLength() - 1);
@@ -585,17 +580,12 @@ otError DatasetManager::SendGetRequest(const otOperationalDatasetComponents &aDa
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
Tlv tlv;
uint8_t datasetTlvs[kMaxDatasetTlvs];
uint8_t length;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(mUriGet);
length = 0;
if (aDatasetComponents.mIsActiveTimestampPresent)
@@ -658,13 +648,17 @@ otError DatasetManager::SendGetRequest(const otOperationalDatasetComponents &aDa
datasetTlvs[length++] = Tlv::kChannelMask;
}
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(mUriGet);
if (aLength + length > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
if (aLength + length > 0)
{
tlv.SetType(Tlv::kGet);
@@ -749,19 +743,15 @@ exit:
return error;
}
void ActiveDataset::HandleGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void ActiveDataset::HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<ActiveDataset *>(aContext)->HandleGet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<ActiveDataset *>(aContext)->HandleGet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void ActiveDataset::HandleGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
void ActiveDataset::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
DatasetManager::Get(aHeader, aMessage, aMessageInfo);
DatasetManager::Get(aMessage, aMessageInfo);
}
void ActiveDataset::HandleTimer(Timer &aTimer)
@@ -885,19 +875,15 @@ exit:
return;
}
void PendingDataset::HandleGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void PendingDataset::HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PendingDataset *>(aContext)->HandleGet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<PendingDataset *>(aContext)->HandleGet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void PendingDataset::HandleGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
void PendingDataset::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
DatasetManager::Get(aHeader, aMessage, aMessageInfo);
DatasetManager::Get(aMessage, aMessageInfo);
}
void PendingDataset::HandleTimer(Timer &aTimer)
src/core/meshcop/dataset_manager.hpp
+14 -28
View File
@@ -224,7 +224,7 @@ protected:
* @param[in] aMessageInfo The message info.
*
*/
void Get(const Coap::Header &aHeader, const Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
void Get(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
/**
* This method compares the partition's Operational Dataset with that stored in non-volatile memory.
@@ -247,10 +247,10 @@ protected:
private:
static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleUdpReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError Register(void);
void SendGetResponse(const Coap::Header & aRequestHeader,
void SendGetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
uint8_t * aTlvs,
uint8_t aLength) const;
@@ -288,12 +288,10 @@ protected:
* @retval OT_ERROR_DROP The MGMT_SET request message was dropped.
*
*/
otError Set(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError Set(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
private:
void SendSetResponse(const Coap::Header & aRequestHeader,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
void SendSetResponse(const Coap::Message &aRequest, const Ip6::MessageInfo &aMessageInfo, StateTlv::State aState);
#endif // OPENTHREAD_FTD
};
@@ -374,18 +372,12 @@ private:
static void HandleTimer(Timer &aTimer);
void HandleTimer(void) { DatasetManager::HandleTimer(); }
static void HandleGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
static void HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
#if OPENTHREAD_FTD
static void HandleSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
bool IsTlvInitialized(Tlv::Type aType);
#endif
@@ -470,7 +462,7 @@ public:
* @param[in] aMessage The MGMT_SET message that contains an Active Dataset.
*
*/
void ApplyActiveDataset(const Timestamp &aTimestamp, Message &aMessage);
void ApplyActiveDataset(const Timestamp &aTimestamp, Coap::Message &aMessage);
#endif
private:
@@ -482,18 +474,12 @@ private:
static void HandleDelayTimer(Timer &aTimer);
void HandleDelayTimer(void);
static void HandleGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
static void HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
#if OPENTHREAD_FTD
static void HandleSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
#endif
TimerMilli mDelayTimer;
src/core/meshcop/dataset_manager_ftd.cpp
+20 -29
View File
@@ -40,7 +40,7 @@
#include <openthread/platform/radio.h>
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -67,7 +67,7 @@ otError DatasetManager::AppendMleDatasetTlv(Message &aMessage) const
return dataset.AppendMleDatasetTlv(aMessage);
}
otError DatasetManager::Set(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
otError DatasetManager::Set(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
Tlv tlv;
@@ -284,26 +284,25 @@ exit:
if (netif.GetMle().GetRole() == OT_DEVICE_ROLE_LEADER)
{
SendSetResponse(aHeader, aMessageInfo, state);
SendSetResponse(aMessage, aMessageInfo, state);
}
return state == StateTlv::kAccept ? OT_ERROR_NONE : OT_ERROR_DROP;
}
void DatasetManager::SendSetResponse(const Coap::Header & aRequestHeader,
void DatasetManager::SendSetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
Message * message;
StateTlv state;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message *message;
StateTlv state;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
state.Init();
state.SetState(aState);
@@ -445,19 +444,15 @@ void ActiveDataset::StopLeader(void)
GetNetif().GetCoap().RemoveResource(mResourceSet);
}
void ActiveDataset::HandleSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void ActiveDataset::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<ActiveDataset *>(aContext)->HandleSet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<ActiveDataset *>(aContext)->HandleSet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void ActiveDataset::HandleSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void ActiveDataset::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
SuccessOrExit(DatasetManager::Set(aHeader, aMessage, aMessageInfo));
SuccessOrExit(DatasetManager::Set(aMessage, aMessageInfo));
ApplyConfiguration();
exit:
@@ -475,26 +470,22 @@ void PendingDataset::StopLeader(void)
GetNetif().GetCoap().RemoveResource(mResourceSet);
}
void PendingDataset::HandleSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void PendingDataset::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PendingDataset *>(aContext)->HandleSet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<PendingDataset *>(aContext)->HandleSet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void PendingDataset::HandleSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void PendingDataset::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
SuccessOrExit(DatasetManager::Set(aHeader, aMessage, aMessageInfo));
SuccessOrExit(DatasetManager::Set(aMessage, aMessageInfo));
StartDelayTimer();
exit:
return;
}
void PendingDataset::ApplyActiveDataset(const Timestamp &aTimestamp, Message &aMessage)
void PendingDataset::ApplyActiveDataset(const Timestamp &aTimestamp, Coap::Message &aMessage)
{
ThreadNetif & netif = GetNetif();
uint16_t offset = aMessage.GetOffset();
src/core/meshcop/energy_scan_client.cpp
+12 -18
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
@@ -74,23 +74,21 @@ otError EnergyScanClient::SendQuery(uint32_t aChannelM
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::CommissionerSessionIdTlv sessionId;
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::CountTlv count;
MeshCoP::PeriodTlv period;
MeshCoP::ScanDurationTlv scanDuration;
Ip6::MessageInfo messageInfo;
Message * message = NULL;
Coap::Message * message = NULL;
VerifyOrExit(netif.GetCommissioner().IsActive(), error = OT_ERROR_INVALID_STATE);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
header.Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ENERGY_SCAN);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_ENERGY_SCAN);
message->SetPayloadMarker();
sessionId.Init();
sessionId.SetCommissionerSessionId(netif.GetCommissioner().GetSessionId());
@@ -134,17 +132,13 @@ exit:
return error;
}
void EnergyScanClient::HandleReport(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void EnergyScanClient::HandleReport(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<EnergyScanClient *>(aContext)->HandleReport(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<EnergyScanClient *>(aContext)->HandleReport(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void EnergyScanClient::HandleReport(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void EnergyScanClient::HandleReport(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
MeshCoP::ChannelMaskTlv channelMask;
@@ -157,7 +151,7 @@ void EnergyScanClient::HandleReport(Coap::Header &aHeader, Message &aMessage, co
uint8_t list[OPENTHREAD_CONFIG_MAX_ENERGY_RESULTS];
} OT_TOOL_PACKED_END energyList;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
otLogInfoMeshCoP("received energy scan report");
@@ -172,7 +166,7 @@ void EnergyScanClient::HandleReport(Coap::Header &aHeader, Message &aMessage, co
mCallback(channelMask.GetMask(), energyList.list, energyList.tlv.GetLength(), mContext);
}
SuccessOrExit(netif.GetCoap().SendEmptyAck(aHeader, responseInfo));
SuccessOrExit(netif.GetCoap().SendEmptyAck(aMessage, responseInfo));
otLogInfoMeshCoP("sent energy scan report response");
src/core/meshcop/energy_scan_client.hpp
+2 -5
View File
@@ -82,11 +82,8 @@ public:
void * aContext);
private:
static void HandleReport(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleReport(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleReport(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleReport(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otCommissionerEnergyReportCallback mCallback;
void * mContext;
src/core/meshcop/joiner.cpp
+29 -35
View File
@@ -339,21 +339,21 @@ void Joiner::HandleSecureCoapClientConnect(bool aConnected)
void Joiner::SendJoinerFinalize(void)
{
ThreadNetif & netif = GetNetif();
Coap::Header header;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Message * message = NULL;
Coap::Message * message = NULL;
StateTlv stateTlv;
VendorNameTlv vendorNameTlv;
VendorModelTlv vendorModelTlv;
VendorSwVersionTlv vendorSwVersionTlv;
VendorStackVersionTlv vendorStackVersionTlv;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_JOINER_FINALIZE);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoapSecure(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_JOINER_FINALIZE);
message->SetPayloadMarker();
message->SetOffset(message->GetLength());
stateTlv.Init();
stateTlv.SetState(MeshCoP::StateTlv::kAccept);
@@ -394,9 +394,10 @@ void Joiner::SendJoinerFinalize(void)
#if OPENTHREAD_ENABLE_CERT_LOG
uint8_t buf[OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE];
VerifyOrExit(message->GetLength() <= sizeof(buf));
message->Read(header.GetLength(), message->GetLength() - header.GetLength(), buf);
otDumpCertMeshCoP("[THCI] direction=send | type=JOIN_FIN.req |", buf, message->GetLength() - header.GetLength());
message->Read(message->GetOffset(), message->GetLength() - message->GetOffset(), buf);
otDumpCertMeshCoP("[THCI] direction=send | type=JOIN_FIN.req |", buf, message->GetLength() - message->GetOffset());
#endif
SuccessOrExit(error = netif.GetCoapSecure().SendMessage(*message, Joiner::HandleJoinerFinalizeResponse, this));
@@ -412,18 +413,15 @@ exit:
}
void Joiner::HandleJoinerFinalizeResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<Joiner *>(aContext)->HandleJoinerFinalizeResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
*static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void Joiner::HandleJoinerFinalizeResponse(Coap::Header * aHeader,
Message * aMessage,
void Joiner::HandleJoinerFinalizeResponse(Coap::Message & aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
@@ -432,9 +430,9 @@ void Joiner::HandleJoinerFinalizeResponse(Coap::Header * aHeader,
StateTlv state;
VerifyOrExit(mState == OT_JOINER_STATE_CONNECTED && aResult == OT_ERROR_NONE &&
aHeader->GetType() == OT_COAP_TYPE_ACKNOWLEDGMENT && aHeader->GetCode() == OT_COAP_CODE_CHANGED);
aMessage.GetType() == OT_COAP_TYPE_ACKNOWLEDGMENT && aMessage.GetCode() == OT_COAP_CODE_CHANGED);
SuccessOrExit(Tlv::GetTlv(*aMessage, Tlv::kState, sizeof(state), state));
SuccessOrExit(Tlv::GetTlv(aMessage, Tlv::kState, sizeof(state), state));
VerifyOrExit(state.IsValid());
mState = OT_JOINER_STATE_ENTRUST;
@@ -443,26 +441,23 @@ void Joiner::HandleJoinerFinalizeResponse(Coap::Header * aHeader,
otLogInfoMeshCoP("received joiner finalize response %d", static_cast<uint8_t>(state.GetState()));
#if OPENTHREAD_ENABLE_CERT_LOG
uint8_t buf[OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE];
VerifyOrExit(aMessage->GetLength() <= sizeof(buf));
aMessage->Read(aHeader->GetLength(), aMessage->GetLength() - aHeader->GetLength(), buf);
otDumpCertMeshCoP("[THCI] direction=recv | type=JOIN_FIN.rsp |", buf, aMessage->GetLength() - aHeader->GetLength());
VerifyOrExit(aMessage.GetLength() <= sizeof(buf));
aMessage.Read(aMessage.GetOffset(), aMessage.GetLength() - aMessage.GetOffset(), buf);
otDumpCertMeshCoP("[THCI] direction=recv | type=JOIN_FIN.rsp |", buf, aMessage.GetLength() - aMessage.GetOffset());
#endif
exit:
Close();
}
void Joiner::HandleJoinerEntrust(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Joiner::HandleJoinerEntrust(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Joiner *>(aContext)->HandleJoinerEntrust(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Joiner *>(aContext)->HandleJoinerEntrust(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Joiner::HandleJoinerEntrust(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Joiner::HandleJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
otError error;
@@ -473,8 +468,8 @@ void Joiner::HandleJoinerEntrust(Coap::Header &aHeader, Message &aMessage, const
ActiveTimestampTlv activeTimestamp;
NetworkKeySequenceTlv networkKeySeq;
VerifyOrExit(mState == OT_JOINER_STATE_ENTRUST && aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE &&
aHeader.GetCode() == OT_COAP_CODE_POST,
VerifyOrExit(mState == OT_JOINER_STATE_ENTRUST && aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE &&
aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
otLogInfoMeshCoP("Received joiner entrust");
@@ -505,6 +500,7 @@ void Joiner::HandleJoinerEntrust(Coap::Header &aHeader, Message &aMessage, const
{
otNetworkName name;
memcpy(name.m8, networkName.GetNetworkName(), networkName.GetLength());
name.m8[networkName.GetLength()] = '\0';
netif.GetMac().SetNetworkName(name.m8);
@@ -513,7 +509,7 @@ void Joiner::HandleJoinerEntrust(Coap::Header &aHeader, Message &aMessage, const
otLogInfoMeshCoP("join success!");
// Send dummy response.
SendJoinerEntrustResponse(aHeader, aMessageInfo);
SendJoinerEntrustResponse(aMessage, aMessageInfo);
// Delay extended address configuration to allow DTLS wrap up.
mTimer.Start(kConfigExtAddressDelay);
@@ -526,17 +522,15 @@ exit:
}
}
void Joiner::SendJoinerEntrustResponse(const Coap::Header &aRequestHeader, const Ip6::MessageInfo &aRequestInfo)
void Joiner::SendJoinerEntrustResponse(const Coap::Message &aRequest, const Ip6::MessageInfo &aRequestInfo)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Message * message;
Coap::Header responseHeader;
Coap::Message * message;
Ip6::MessageInfo responseInfo(aRequestInfo);
responseHeader.SetDefaultResponseHeader(aRequestHeader);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetSubType(Message::kSubTypeJoinerEntrust);
memset(&responseInfo.mSockAddr, 0, sizeof(responseInfo.mSockAddr));
src/core/meshcop/joiner.hpp
+5 -12
View File
@@ -39,7 +39,7 @@
#include <openthread/joiner.h>
#include "coap/coap.hpp"
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "coap/coap_secure.hpp"
#include "common/crc16.hpp"
#include "common/locator.hpp"
@@ -150,21 +150,14 @@ private:
void SendJoinerFinalize(void);
static void HandleJoinerFinalizeResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleJoinerFinalizeResponse(Coap::Header * aHeader,
Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult);
void HandleJoinerFinalizeResponse(Coap::Message &aMessage, const Ip6::MessageInfo *aMessageInfo, otError aResult);
static void HandleJoinerEntrust(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleJoinerEntrust(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void SendJoinerEntrustResponse(const Coap::Header &aRequestHeader, const Ip6::MessageInfo &aRequestInfo);
static void HandleJoinerEntrust(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void SendJoinerEntrustResponse(const Coap::Message &aRequest, const Ip6::MessageInfo &aRequestInfo);
otJoinerState mState;
src/core/meshcop/joiner_router.cpp
+21 -30
View File
@@ -140,8 +140,7 @@ void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &a
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message = NULL;
Coap::Header header;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
JoinerUdpPortTlv udpPort;
JoinerIidTlv iid;
@@ -154,12 +153,12 @@ void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &a
SuccessOrExit(error = GetBorderAgentRloc(GetNetif(), borderAgentRloc));
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_RELAY_RX);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_RELAY_RX);
message->SetPayloadMarker();
udpPort.Init();
udpPort.SetUdpPort(aMessageInfo.GetPeerPort());
@@ -197,17 +196,13 @@ exit:
}
}
void JoinerRouter::HandleRelayTransmit(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void JoinerRouter::HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<JoinerRouter *>(aContext)->HandleRelayTransmit(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<JoinerRouter *>(aContext)->HandleRelayTransmit(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void JoinerRouter::HandleRelayTransmit(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void JoinerRouter::HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
@@ -221,7 +216,7 @@ void JoinerRouter::HandleRelayTransmit(Coap::Header &aHeader, Message &aMessage,
otMessageSettings settings = {false, static_cast<otMessagePriority>(kMeshCoPMessagePriority)};
Ip6::MessageInfo messageInfo;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST,
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
otLogInfoMeshCoP("Received relay transmit");
@@ -280,8 +275,7 @@ otError JoinerRouter::DelaySendingJoinerEntrust(const Ip6::MessageInfo &aMessage
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message = NULL;
Coap::Header header;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
Dataset dataset(MeshCoP::Tlv::kActiveTimestamp);
@@ -294,11 +288,11 @@ otError JoinerRouter::DelaySendingJoinerEntrust(const Ip6::MessageInfo &aMessage
DelayedJoinEntHeader delayedMessage;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_JOINER_ENTRUST);
header.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_JOINER_ENTRUST);
message->SetPayloadMarker();
message->SetSubType(Message::kSubTypeJoinerEntrust);
masterKey.Init();
@@ -402,7 +396,7 @@ void JoinerRouter::SendDelayedJoinerEntrust(void)
{
ThreadNetif & netif = GetNetif();
DelayedJoinEntHeader delayedJoinEnt;
Message * message = mDelayedJoinEnts.GetHead();
Coap::Message * message = static_cast<Coap::Message *>(mDelayedJoinEnts.GetHead());
uint32_t now = TimerMilli::GetNow();
Ip6::MessageInfo messageInfo;
@@ -443,7 +437,7 @@ exit:
return;
}
otError JoinerRouter::SendJoinerEntrust(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
otError JoinerRouter::SendJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif &netif = GetNetif();
otError error;
@@ -464,18 +458,15 @@ exit:
}
void JoinerRouter::HandleJoinerEntrustResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<JoinerRouter *>(aContext)->HandleJoinerEntrustResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void JoinerRouter::HandleJoinerEntrustResponse(Coap::Header * aHeader,
Message * aMessage,
void JoinerRouter::HandleJoinerEntrustResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
@@ -484,9 +475,9 @@ void JoinerRouter::HandleJoinerEntrustResponse(Coap::Header * aHeader,
mExpectJoinEntRsp = false;
SendDelayedJoinerEntrust();
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader != NULL && aMessage != NULL);
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage != NULL);
VerifyOrExit(aHeader->GetCode() == OT_COAP_CODE_CHANGED);
VerifyOrExit(aMessage->GetCode() == OT_COAP_CODE_CHANGED);
otLogInfoMeshCoP("Receive joiner entrust response");
otLogCertMeshCoP("[THCI] direction=recv | type=JOIN_ENT.rsp");
src/core/meshcop/joiner_router.hpp
+5 -12
View File
@@ -37,7 +37,7 @@
#include "openthread-core-config.h"
#include "coap/coap.hpp"
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/locator.hpp"
#include "common/message.hpp"
#include "common/notifier.hpp"
@@ -92,28 +92,21 @@ private:
static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleRelayTransmit(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleRelayTransmit(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleJoinerEntrustResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError result);
void HandleJoinerEntrustResponse(Coap::Header * aHeader,
Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError result);
void HandleJoinerEntrustResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, otError result);
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
otError DelaySendingJoinerEntrust(const Ip6::MessageInfo &aMessageInfo, const JoinerRouterKekTlv &aKek);
void SendDelayedJoinerEntrust(void);
otError SendJoinerEntrust(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Ip6::UdpSocket mSocket;
Coap::Resource mRelayTransmit;
src/core/meshcop/leader.cpp
+27 -38
View File
@@ -41,7 +41,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/instance.hpp"
#include "common/logging.hpp"
@@ -67,17 +67,13 @@ Leader::Leader(Instance &aInstance)
GetNetif().GetCoap().AddResource(mKeepAlive);
}
void Leader::HandlePetition(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Leader::HandlePetition(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandlePetition(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Leader *>(aContext)->HandlePetition(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Leader::HandlePetition(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Leader::HandlePetition(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
@@ -118,24 +114,23 @@ void Leader::HandlePetition(Coap::Header &aHeader, Message &aMessage, const Ip6:
mTimer.Start(TimerMilli::SecToMsec(kTimeoutLeaderPetition));
exit:
SendPetitionResponse(aHeader, aMessageInfo, state);
SendPetitionResponse(aMessage, aMessageInfo, state);
}
otError Leader::SendPetitionResponse(const Coap::Header & aRequestHeader,
otError Leader::SendPetitionResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
StateTlv state;
CommissionerSessionIdTlv sessionId;
Message * message;
Coap::Message * message;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
state.Init();
state.SetState(aState);
@@ -168,17 +163,13 @@ exit:
return error;
}
void Leader::HandleKeepAlive(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Leader::HandleKeepAlive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandleKeepAlive(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Leader *>(aContext)->HandleKeepAlive(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Leader::HandleKeepAlive(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Leader::HandleKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
NetworkData::Leader & netdata = GetNetif().GetNetworkDataLeader();
StateTlv state;
@@ -220,26 +211,25 @@ void Leader::HandleKeepAlive(Coap::Header &aHeader, Message &aMessage, const Ip6
mTimer.Start(TimerMilli::SecToMsec(kTimeoutLeaderPetition));
}
SendKeepAliveResponse(aHeader, aMessageInfo, responseState);
SendKeepAliveResponse(aMessage, aMessageInfo, responseState);
exit:
return;
}
otError Leader::SendKeepAliveResponse(const Coap::Header & aRequestHeader,
otError Leader::SendKeepAliveResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
StateTlv state;
Message * message;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
StateTlv state;
Coap::Message *message;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
state.Init();
state.SetState(aState);
@@ -263,15 +253,14 @@ otError Leader::SendDatasetChanged(const Ip6::Address &aAddress)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Ip6::MessageInfo messageInfo;
Message * message;
Coap::Message * message;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_DATASET_CHANGED);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_DATASET_CHANGED);
messageInfo.SetSockAddr(netif.GetMle().GetMeshLocal16());
messageInfo.SetPeerAddr(aAddress);
src/core/meshcop/leader.hpp
+6 -12
View File
@@ -117,21 +117,15 @@ private:
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
static void HandlePetition(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandlePetition(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendPetitionResponse(const Coap::Header & aRequestHeader,
static void HandlePetition(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandlePetition(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendPetitionResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
static void HandleKeepAlive(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleKeepAlive(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendKeepAliveResponse(const Coap::Header & aRequestHeader,
static void HandleKeepAlive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otError SendKeepAliveResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
src/core/meshcop/meshcop.hpp
+2 -2
View File
@@ -55,10 +55,10 @@ enum
* This function create Message for MeshCoP
*
*/
inline Message *NewMeshCoPMessage(Coap::Coap &aCoap, const Coap::Header &aHeader)
inline Coap::Message *NewMeshCoPMessage(Coap::Coap &aCoap)
{
otMessageSettings settings = {true, static_cast<otMessagePriority>(kMeshCoPMessagePriority)};
return aCoap.NewMessage(aHeader, &settings);
return aCoap.NewMessage(&settings);
}
/**
src/core/meshcop/panid_query_client.cpp
+12 -18
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -68,21 +68,19 @@ otError PanIdQueryClient::SendQuery(uint16_t aPanId,
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::CommissionerSessionIdTlv sessionId;
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::PanIdTlv panId;
Ip6::MessageInfo messageInfo;
Message * message = NULL;
Coap::Message * message = NULL;
VerifyOrExit(netif.GetCommissioner().IsActive(), error = OT_ERROR_INVALID_STATE);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
header.Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_PANID_QUERY);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_PANID_QUERY);
message->SetPayloadMarker();
sessionId.Init();
sessionId.SetCommissionerSessionId(netif.GetCommissioner().GetSessionId());
@@ -118,24 +116,20 @@ exit:
return error;
}
void PanIdQueryClient::HandleConflict(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void PanIdQueryClient::HandleConflict(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PanIdQueryClient *>(aContext)->HandleConflict(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<PanIdQueryClient *>(aContext)->HandleConflict(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void PanIdQueryClient::HandleConflict(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void PanIdQueryClient::HandleConflict(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
MeshCoP::PanIdTlv panId;
MeshCoP::ChannelMaskTlv channelMask;
Ip6::MessageInfo responseInfo(aMessageInfo);
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
otLogInfoMeshCoP("received panid conflict");
@@ -150,7 +144,7 @@ void PanIdQueryClient::HandleConflict(Coap::Header &aHeader, Message &aMessage,
mCallback(panId.GetPanId(), channelMask.GetMask(), mContext);
}
SuccessOrExit(netif.GetCoap().SendEmptyAck(aHeader, responseInfo));
SuccessOrExit(netif.GetCoap().SendEmptyAck(aMessage, responseInfo));
otLogInfoMeshCoP("sent panid query conflict response");
src/core/meshcop/panid_query_client.hpp
+2 -5
View File
@@ -78,11 +78,8 @@ public:
void * aContext);
private:
static void HandleConflict(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleConflict(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleConflict(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleConflict(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otCommissionerPanIdConflictCallback mCallback;
void * mContext;
src/core/net/udp6.cpp
+2
View File
@@ -418,6 +418,8 @@ void Udp::HandlePayload(Message &aMessage, MessageInfo &aMessageInfo)
}
}
aMessage.RemoveHeader(aMessage.GetOffset());
assert(aMessage.GetOffset() == 0);
socket->HandleUdpReceive(aMessage, aMessageInfo);
break;
}
src/core/thread/address_resolver.cpp
+31 -48
View File
@@ -39,7 +39,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
@@ -320,16 +320,15 @@ otError AddressResolver::SendAddressQuery(const Ip6::Address &aEid)
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message;
Coap::Header header;
Coap::Message * message;
ThreadTargetTlv targetTlv;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_ADDRESS_QUERY);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_ADDRESS_QUERY);
message->SetPayloadMarker();
targetTlv.Init();
targetTlv.SetTarget(aEid);
@@ -360,19 +359,13 @@ exit:
return error;
}
void AddressResolver::HandleAddressNotification(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void AddressResolver::HandleAddressNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AddressResolver *>(aContext)->HandleAddressNotification(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void AddressResolver::HandleAddressNotification(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void AddressResolver::HandleAddressNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
ThreadTargetTlv targetTlv;
@@ -381,7 +374,7 @@ void AddressResolver::HandleAddressNotification(Coap::Header & aHeader,
ThreadLastTransactionTimeTlv lastTransactionTimeTlv;
uint32_t lastTransactionTime;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(ThreadTlv::GetTlv(aMessage, ThreadTlv::kTarget, sizeof(targetTlv), targetTlv));
VerifyOrExit(targetTlv.IsValid());
@@ -447,7 +440,7 @@ void AddressResolver::HandleAddressNotification(Coap::Header & aHeader,
otLogNoteArp("Cache entry updated (notification): %s, 0x%04x, lastTrans:%d",
targetTlv.GetTarget().ToString().AsCString(), rloc16Tlv.GetRloc16(), lastTransactionTime);
if (netif.GetCoap().SendEmptyAck(aHeader, aMessageInfo) == OT_ERROR_NONE)
if (netif.GetCoap().SendEmptyAck(aMessage, aMessageInfo) == OT_ERROR_NONE)
{
otLogInfoArp("Sending address notification acknowledgment");
}
@@ -467,15 +460,14 @@ otError AddressResolver::SendAddressError(const ThreadTargetTlv & aTarget,
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message;
Coap::Header header;
Coap::Message * message;
Ip6::MessageInfo messageInfo;
header.Init(aDestination == NULL ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_ADDRESS_ERROR);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(aDestination == NULL ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_ADDRESS_ERROR);
message->SetPayloadMarker();
SuccessOrExit(error = message->Append(&aTarget, sizeof(aTarget)));
SuccessOrExit(error = message->Append(&aEid, sizeof(aEid)));
@@ -508,17 +500,13 @@ exit:
return error;
}
void AddressResolver::HandleAddressError(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void AddressResolver::HandleAddressError(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AddressResolver *>(aContext)->HandleAddressError(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<AddressResolver *>(aContext)->HandleAddressError(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void AddressResolver::HandleAddressError(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void AddressResolver::HandleAddressError(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
@@ -527,14 +515,14 @@ void AddressResolver::HandleAddressError(Coap::Header &aHeader, Message &aMessag
Mac::ExtAddress macAddr;
Ip6::Address destination;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST,
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
otLogInfoArp("Received address error notification");
if (aHeader.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
{
if (netif.GetCoap().SendEmptyAck(aHeader, aMessageInfo) == OT_ERROR_NONE)
if (netif.GetCoap().SendEmptyAck(aMessage, aMessageInfo) == OT_ERROR_NONE)
{
otLogInfoArp("Sent address error notification acknowledgment");
}
@@ -596,24 +584,20 @@ exit:
return;
}
void AddressResolver::HandleAddressQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void AddressResolver::HandleAddressQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AddressResolver *>(aContext)->HandleAddressQuery(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<AddressResolver *>(aContext)->HandleAddressQuery(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void AddressResolver::HandleAddressQuery(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void AddressResolver::HandleAddressQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
ThreadTargetTlv targetTlv;
ThreadMeshLocalEidTlv mlIidTlv;
ThreadLastTransactionTimeTlv lastTransactionTimeTlv;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(ThreadTlv::GetTlv(aMessage, ThreadTlv::kTarget, sizeof(targetTlv), targetTlv));
VerifyOrExit(targetTlv.IsValid());
@@ -661,16 +645,15 @@ void AddressResolver::SendAddressQueryResponse(const ThreadTargetTlv &
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message;
Coap::Header header;
Coap::Message * message;
ThreadRloc16Tlv rloc16Tlv;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.AppendUriPathOptions(OT_URI_PATH_ADDRESS_NOTIFY);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->AppendUriPathOptions(OT_URI_PATH_ADDRESS_NOTIFY);
message->SetPayloadMarker();
SuccessOrExit(error = message->Append(&aTargetTlv, sizeof(aTargetTlv)));
SuccessOrExit(error = message->Append(&aMlIidTlv, sizeof(aMlIidTlv)));
src/core/thread/address_resolver.hpp
+6 -15
View File
@@ -193,23 +193,14 @@ private:
static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
static void HandleAddressError(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleAddressError(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressError(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleAddressError(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleAddressQuery(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleAddressQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressNotification(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleAddressNotification(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleAddressNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleIcmpReceive(void * aContext,
otMessage * aMessage,
src/core/thread/announce_begin_server.cpp
+7 -11
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/radio.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -68,24 +68,20 @@ otError AnnounceBeginServer::SendAnnounce(uint32_t aChannelMask, uint8_t aCount,
return AnnounceSenderBase::SendAnnounce(Mac::ChannelMask(aChannelMask), aCount, aPeriod, kDefaultJitter);
}
void AnnounceBeginServer::HandleRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void AnnounceBeginServer::HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AnnounceBeginServer *>(aContext)->HandleRequest(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<AnnounceBeginServer *>(aContext)->HandleRequest(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void AnnounceBeginServer::HandleRequest(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void AnnounceBeginServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::CountTlv count;
MeshCoP::PeriodTlv period;
Ip6::MessageInfo responseInfo(aMessageInfo);
VerifyOrExit(aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(MeshCoP::Tlv::GetTlv(aMessage, MeshCoP::Tlv::kChannelMask, sizeof(channelMask), channelMask));
VerifyOrExit(channelMask.IsValid() && (channelMask.GetChannelPage() == OT_RADIO_CHANNEL_PAGE));
@@ -98,9 +94,9 @@ void AnnounceBeginServer::HandleRequest(Coap::Header &aHeader, Message &aMessage
SendAnnounce(channelMask.GetMask(), count.GetCount(), period.GetPeriod());
if (aHeader.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, responseInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, responseInfo));
otLogInfoMeshCoP("sent announce begin response");
}
src/core/thread/announce_begin_server.hpp
+2 -5
View File
@@ -87,11 +87,8 @@ private:
kDefaultJitter = 0,
};
static void HandleRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleRequest(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleTimer(Timer &aTimer);
src/core/thread/energy_scan_server.cpp
+13 -19
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -67,17 +67,13 @@ EnergyScanServer::EnergyScanServer(Instance &aInstance)
GetNetif().GetCoap().AddResource(mEnergyScan);
}
void EnergyScanServer::HandleRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void EnergyScanServer::HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<EnergyScanServer *>(aContext)->HandleRequest(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<EnergyScanServer *>(aContext)->HandleRequest(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void EnergyScanServer::HandleRequest(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void EnergyScanServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
MeshCoP::CountTlv count;
MeshCoP::PeriodTlv period;
@@ -85,7 +81,7 @@ void EnergyScanServer::HandleRequest(Coap::Header &aHeader, Message &aMessage, c
MeshCoP::ChannelMaskTlv channelMask;
Ip6::MessageInfo responseInfo(aMessageInfo);
VerifyOrExit(aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(MeshCoP::Tlv::GetTlv(aMessage, MeshCoP::Tlv::kCount, sizeof(count), count));
VerifyOrExit(count.IsValid());
@@ -110,9 +106,9 @@ void EnergyScanServer::HandleRequest(Coap::Header &aHeader, Message &aMessage, c
mCommissioner = aMessageInfo.GetPeerAddr();
if (aHeader.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, responseInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, responseInfo));
otLogInfoMeshCoP("sent energy scan query response");
}
@@ -185,19 +181,17 @@ exit:
otError EnergyScanServer::SendReport(void)
{
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::EnergyListTlv energyList;
Ip6::MessageInfo messageInfo;
Message * message;
Coap::Message * message;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ENERGY_REPORT);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap(), header)) != NULL,
error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_ENERGY_REPORT);
message->SetPayloadMarker();
channelMask.Init();
channelMask.SetChannelPage(OT_RADIO_CHANNEL_PAGE);
src/core/thread/energy_scan_server.hpp
+2 -5
View File
@@ -66,11 +66,8 @@ private:
kReportDelay = 500, ///< Delay before sending a report (milliseconds)
};
static void HandleRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleRequest(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleScanResult(void *aContext, otEnergyScanResult *aResult);
void HandleScanResult(otEnergyScanResult *aResult);
src/core/thread/mle_router.cpp
+31 -45
View File
@@ -3811,21 +3811,20 @@ otError MleRouter::SendAddressSolicit(ThreadStatusTlv::Status aStatus)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
ThreadExtMacAddressTlv macAddr64Tlv;
ThreadRloc16Tlv rlocTlv;
ThreadStatusTlv statusTlv;
Ip6::MessageInfo messageInfo;
Message * message = NULL;
Coap::Message * message = NULL;
VerifyOrExit(mAddressSolicitPending == false);
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ADDRESS_SOLICIT);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_ADDRESS_SOLICIT);
message->SetPayloadMarker();
macAddr64Tlv.Init();
macAddr64Tlv.SetMacAddr(netif.GetMac().GetExtAddress());
@@ -3870,18 +3869,17 @@ otError MleRouter::SendAddressRelease(void)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
ThreadRloc16Tlv rlocTlv;
ThreadExtMacAddressTlv macAddr64Tlv;
Ip6::MessageInfo messageInfo;
Message * message;
Coap::Message * message;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ADDRESS_RELEASE);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_ADDRESS_RELEASE);
message->SetPayloadMarker();
rlocTlv.Init();
rlocTlv.SetRloc16(GetRloc16(mRouterId));
@@ -3909,18 +3907,15 @@ exit:
}
void MleRouter::HandleAddressSolicitResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<MleRouter *>(aContext)->HandleAddressSolicitResponse(
static_cast<Coap::Header *>(aHeader), static_cast<Message *>(aMessage),
static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
static_cast<Coap::Message *>(aMessage), static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void MleRouter::HandleAddressSolicitResponse(Coap::Header * aHeader,
Message * aMessage,
void MleRouter::HandleAddressSolicitResponse(Coap::Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError aResult)
{
@@ -3935,9 +3930,9 @@ void MleRouter::HandleAddressSolicitResponse(Coap::Header * aHeader,
mAddressSolicitPending = false;
VerifyOrExit(aResult == OT_ERROR_NONE && aHeader != NULL && aMessage != NULL);
VerifyOrExit(aResult == OT_ERROR_NONE && aMessage != NULL && aMessage != NULL);
VerifyOrExit(aHeader->GetCode() == OT_COAP_CODE_CHANGED);
VerifyOrExit(aMessage->GetCode() == OT_COAP_CODE_CHANGED);
LogMleMessage("Receive Address Reply", aMessageInfo->GetPeerAddr());
@@ -4024,17 +4019,13 @@ exit:
return;
}
void MleRouter::HandleAddressSolicit(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void MleRouter::HandleAddressSolicit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<MleRouter *>(aContext)->HandleAddressSolicit(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<MleRouter *>(aContext)->HandleAddressSolicit(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void MleRouter::HandleAddressSolicit(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void MleRouter::HandleAddressSolicit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
otError error = OT_ERROR_NONE;
ThreadExtMacAddressTlv macAddr64Tlv;
@@ -4045,7 +4036,7 @@ void MleRouter::HandleAddressSolicit(Coap::Header &aHeader, Message &aMessage, c
XtalAccuracyTlv xtalAccuracyTlv;
#endif
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST,
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_PARSE);
LogMleMessage("Receive Address Solicit", aMessageInfo.GetPeerAddr());
@@ -4118,26 +4109,25 @@ exit:
if (error == OT_ERROR_NONE)
{
SendAddressSolicitResponse(aHeader, router, aMessageInfo);
SendAddressSolicitResponse(aMessage, router, aMessageInfo);
}
}
void MleRouter::SendAddressSolicitResponse(const Coap::Header & aRequestHeader,
void MleRouter::SendAddressSolicitResponse(const Coap::Message & aRequestHeader,
const Router * aRouter,
const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
ThreadStatusTlv statusTlv;
ThreadRouterMaskTlv routerMaskTlv;
ThreadRloc16Tlv rlocTlv;
Message * message;
Coap::Message * message;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequestHeader);
message->SetPayloadMarker();
statusTlv.Init();
statusTlv.SetStatus(aRouter == NULL ? statusTlv.kNoAddressAvailable : statusTlv.kSuccess);
@@ -4176,24 +4166,20 @@ exit:
}
}
void MleRouter::HandleAddressRelease(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void MleRouter::HandleAddressRelease(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<MleRouter *>(aContext)->HandleAddressRelease(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<MleRouter *>(aContext)->HandleAddressRelease(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void MleRouter::HandleAddressRelease(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void MleRouter::HandleAddressRelease(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadRloc16Tlv rlocTlv;
ThreadExtMacAddressTlv macAddr64Tlv;
uint8_t routerId;
Router * router;
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
LogMleMessage("Receive Address Release", aMessageInfo.GetPeerAddr());
@@ -4210,7 +4196,7 @@ void MleRouter::HandleAddressRelease(Coap::Header &aHeader, Message &aMessage, c
mRouterTable.Release(routerId);
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, aMessageInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, aMessageInfo));
LogMleMessage("Send Address Release Reply", aMessageInfo.GetPeerAddr());
src/core/thread/mle_router_ftd.hpp
+7 -17
View File
@@ -41,7 +41,7 @@
#include <openthread/thread_ftd.h>
#include "coap/coap.hpp"
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/timer.hpp"
#include "common/trickle_timer.hpp"
#include "mac/mac_frame.hpp"
@@ -726,7 +726,7 @@ private:
void StopAdvertiseTimer(void);
otError SendAddressSolicit(ThreadStatusTlv::Status aStatus);
otError SendAddressRelease(void);
void SendAddressSolicitResponse(const Coap::Header & aRequest,
void SendAddressSolicitResponse(const Coap::Message & aRequest,
const Router * aRouter,
const Ip6::MessageInfo &aMessageInfo);
otError SendAdvertisement(void);
@@ -756,24 +756,14 @@ private:
void UpdateRoutes(const RouteTlv &aTlv, uint8_t aRouterId);
static void HandleAddressSolicitResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError result);
void HandleAddressSolicitResponse(Coap::Header * aHeader,
Message * aMessage,
const Ip6::MessageInfo *aMessageInfo,
otError result);
static void HandleAddressRelease(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleAddressRelease(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressSolicit(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleAddressSolicit(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleAddressSolicitResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, otError result);
static void HandleAddressRelease(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleAddressRelease(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleAddressSolicit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleAddressSolicit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static bool IsSingleton(const RouteTlv &aRouteTlv);
src/core/thread/network_data.cpp
+9 -10
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -997,21 +997,20 @@ otError NetworkData::Remove(uint8_t *aStart, uint8_t aLength)
otError NetworkData::SendServerDataNotification(uint16_t aRloc16)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
Message * message = NULL;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
VerifyOrExit(!mLastAttemptWait || static_cast<int32_t>(TimerMilli::GetNow() - mLastAttempt) < kDataResubmitDelay,
error = OT_ERROR_ALREADY);
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_SERVER_DATA);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_SERVER_DATA);
message->SetPayloadMarker();
if (mType == kTypeLocal)
{
src/core/thread/network_data_leader.cpp
+1 -1
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
src/core/thread/network_data_leader_ftd.cpp
+29 -45
View File
@@ -39,7 +39,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
@@ -148,17 +148,13 @@ exit:
return;
}
void Leader::HandleServerData(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Leader::HandleServerData(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandleServerData(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Leader *>(aContext)->HandleServerData(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Leader::HandleServerData(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Leader::HandleServerData(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetworkDataTlv networkData;
ThreadRloc16Tlv rloc16;
@@ -178,7 +174,7 @@ void Leader::HandleServerData(Coap::Header &aHeader, Message &aMessage, const Ip
networkData.GetLength());
}
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, aMessageInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, aMessageInfo));
otLogInfoNetData("Sent network data registration acknowledgment");
@@ -186,17 +182,13 @@ exit:
return;
}
void Leader::HandleCommissioningSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Leader::HandleCommissioningSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandleCommissioningSet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Leader *>(aContext)->HandleCommissioningSet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Leader::HandleCommissioningSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Leader::HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint16_t offset = aMessage.GetOffset();
uint16_t length = aMessage.GetLength() - aMessage.GetOffset();
@@ -291,23 +283,19 @@ exit:
if (GetNetif().GetMle().GetRole() == OT_DEVICE_ROLE_LEADER)
{
SendCommissioningSetResponse(aHeader, aMessageInfo, state);
SendCommissioningSetResponse(aMessage, aMessageInfo, state);
}
return;
}
void Leader::HandleCommissioningGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void Leader::HandleCommissioningGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandleCommissioningGet(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<Leader *>(aContext)->HandleCommissioningGet(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void Leader::HandleCommissioningGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Leader::HandleCommissioningGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
MeshCoP::Tlv tlv;
uint16_t offset = aMessage.GetOffset();
@@ -328,27 +316,25 @@ void Leader::HandleCommissioningGet(Coap::Header &aHeader, Message &aMessage, co
offset += sizeof(tlv) + tlv.GetLength();
}
SendCommissioningGetResponse(aHeader, aMessageInfo, tlvs, length);
SendCommissioningGetResponse(aMessage, aMessageInfo, tlvs, length);
}
void Leader::SendCommissioningGetResponse(const Coap::Header & aRequestHeader,
void Leader::SendCommissioningGetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
uint8_t * aTlvs,
uint8_t aLength)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
Message * message;
uint8_t index;
uint8_t * data = NULL;
uint8_t length = 0;
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Message *message;
uint8_t index;
uint8_t * data = NULL;
uint8_t length = 0;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL,
error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
for (NetworkDataTlv *cur = reinterpret_cast<NetworkDataTlv *>(mTlvs);
cur < reinterpret_cast<NetworkDataTlv *>(mTlvs + mLength); cur = cur->GetNext())
@@ -383,7 +369,7 @@ void Leader::SendCommissioningGetResponse(const Coap::Header & aRequestHeader
}
}
if (message->GetLength() == responseHeader.GetLength())
if (message->GetLength() == message->GetOffset())
{
// no payload, remove coap payload marker
message->SetLength(message->GetLength() - 1);
@@ -401,21 +387,19 @@ exit:
}
}
void Leader::SendCommissioningSetResponse(const Coap::Header & aRequestHeader,
void Leader::SendCommissioningSetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo & aMessageInfo,
MeshCoP::StateTlv::State aState)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
Message * message;
Coap::Message * message;
MeshCoP::StateTlv state;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL,
error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aRequest);
message->SetPayloadMarker();
state.Init();
state.SetState(aState);
src/core/thread/network_data_leader_ftd.hpp
+8 -17
View File
@@ -171,11 +171,8 @@ public:
#endif
private:
static void HandleServerData(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleServerData(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleServerData(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleServerData(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
@@ -221,23 +218,17 @@ private:
bool IsStableUpdated(uint8_t *aTlvs, uint8_t aTlvsLength, uint8_t *aTlvsBase, uint8_t aTlvsBaseLength);
static void HandleCommissioningSet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleCommissioningSet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleCommissioningSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleCommissioningGet(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleCommissioningGet(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleCommissioningGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleCommissioningGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void SendCommissioningGetResponse(const Coap::Header & aRequestHeader,
void SendCommissioningGetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo &aMessageInfo,
uint8_t * aTlvs,
uint8_t aLength);
void SendCommissioningSetResponse(const Coap::Header & aRequestHeader,
void SendCommissioningSetResponse(const Coap::Message & aRequest,
const Ip6::MessageInfo & aMessageInfo,
MeshCoP::StateTlv::State aState);
src/core/thread/network_diagnostic.cpp
+54 -81
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/encoding.hpp"
@@ -88,32 +88,31 @@ otError NetworkDiagnostic::SendDiagnosticGet(const Ip6::Address &aDestination,
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message = NULL;
Coap::Header header;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
otCoapResponseHandler handler = NULL;
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
if (aDestination.IsMulticast())
{
header.Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_QUERY);
message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_QUERY);
}
else
{
handler = &NetworkDiagnostic::HandleDiagnosticGetResponse;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_REQUEST);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_REQUEST);
}
if (aCount > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
if (aCount > 0)
{
TypeListTlv tlv;
@@ -144,23 +143,20 @@ exit:
}
void NetworkDiagnostic::HandleDiagnosticGetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult)
{
static_cast<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetResponse(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo), aResult);
}
void NetworkDiagnostic::HandleDiagnosticGetResponse(Coap::Header & aHeader,
Message & aMessage,
void NetworkDiagnostic::HandleDiagnosticGetResponse(Coap::Message & aMessage,
const Ip6::MessageInfo &aMessageInfo,
otError aResult)
{
VerifyOrExit(aResult == OT_ERROR_NONE);
VerifyOrExit(aHeader.GetCode() == OT_COAP_CODE_CHANGED);
VerifyOrExit(aMessage.GetCode() == OT_COAP_CODE_CHANGED);
otLogInfoNetDiag("Received diagnostic get response");
@@ -174,20 +170,16 @@ exit:
}
void NetworkDiagnostic::HandleDiagnosticGetAnswer(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
static_cast<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetAnswer(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetAnswer(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticGetAnswer(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
otLogInfoNetDiag("Diagnostic get answer received");
@@ -196,7 +188,7 @@ void NetworkDiagnostic::HandleDiagnosticGetAnswer(Coap::Header & aHeade
mReceiveDiagnosticGetCallback(&aMessage, &aMessageInfo, mReceiveDiagnosticGetCallbackContext);
}
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, aMessageInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, aMessageInfo));
otLogInfoNetDiag("Sent diagnostic answer acknowledgment");
@@ -465,28 +457,21 @@ exit:
return error;
}
void NetworkDiagnostic::HandleDiagnosticGetQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticGetQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetQuery(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Message * message = NULL;
Coap::Message * message = NULL;
NetworkDiagnosticTlv networkDiagnosticTlv;
Coap::Header header;
Ip6::MessageInfo messageInfo;
VerifyOrExit(aHeader.GetCode() == OT_COAP_CODE_POST, error = OT_ERROR_DROP);
VerifyOrExit(aMessage.GetCode() == OT_COAP_CODE_POST, error = OT_ERROR_DROP);
otLogInfoNetDiag("Received diagnostic get query");
@@ -499,25 +484,25 @@ void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Header & aHeader
VerifyOrExit((static_cast<TypeListTlv *>(&networkDiagnosticTlv)->IsValid()), error = OT_ERROR_DROP);
// DIAG_GET.qry may be sent as a confirmable message.
if (aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE)
if (aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE)
{
if (netif.GetCoap().SendEmptyAck(aHeader, aMessageInfo) == OT_ERROR_NONE)
if (netif.GetCoap().SendEmptyAck(aMessage, aMessageInfo) == OT_ERROR_NONE)
{
otLogInfoNetDiag("Sent diagnostic get query acknowledgment");
}
}
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_ANSWER);
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_GET_ANSWER);
if (networkDiagnosticTlv.GetLength() > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
messageInfo.SetSockAddr(GetNetif().GetMle().GetMeshLocal16());
messageInfo.SetPeerAddr(aMessageInfo.GetPeerAddr());
messageInfo.SetPeerPort(kCoapUdpPort);
@@ -525,10 +510,10 @@ void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Header & aHeader
SuccessOrExit(error = FillRequestedTlvs(aMessage, *message, networkDiagnosticTlv));
if (message->GetLength() == header.GetLength())
if (message->GetLength() == message->GetOffset())
{
// Remove Payload Marker if payload is actually empty.
message->SetLength(header.GetLength() - 1);
message->SetLength(message->GetLength() - 1);
}
SuccessOrExit(error = netif.GetCoap().SendMessage(*message, messageInfo, NULL, this));
@@ -544,27 +529,22 @@ exit:
}
void NetworkDiagnostic::HandleDiagnosticGetRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
static_cast<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetRequest(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetRequest(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticGetRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Message * message = NULL;
Coap::Message * message = NULL;
NetworkDiagnosticTlv networkDiagnosticTlv;
Coap::Header header;
Ip6::MessageInfo messageInfo(aMessageInfo);
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST,
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
otLogInfoNetDiag("Received diagnostic get request");
@@ -577,17 +557,17 @@ void NetworkDiagnostic::HandleDiagnosticGetRequest(Coap::Header & aHead
VerifyOrExit((static_cast<TypeListTlv *>(&networkDiagnosticTlv)->IsValid()), error = OT_ERROR_DROP);
header.SetDefaultResponseHeader(aHeader);
header.SetPayloadMarker();
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
message->SetDefaultResponseHeader(aMessage);
message->SetPayloadMarker();
SuccessOrExit(error = FillRequestedTlvs(aMessage, *message, networkDiagnosticTlv));
if (message->GetLength() == header.GetLength())
if (message->GetLength() == message->GetOffset())
{
// Remove Payload Marker if payload is actually empty.
message->SetLength(header.GetLength() - 1);
message->SetLength(message->GetOffset() - 1);
}
SuccessOrExit(error = netif.GetCoap().SendMessage(*message, messageInfo));
@@ -608,21 +588,20 @@ otError NetworkDiagnostic::SendDiagnosticReset(const Ip6::Address &aDestination,
{
ThreadNetif & netif = GetNetif();
otError error;
Message * message = NULL;
Coap::Header header;
Coap::Message * message = NULL;
Ip6::MessageInfo messageInfo;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_RESET);
VerifyOrExit((message = netif.GetCoap().NewMessage()) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_DIAGNOSTIC_RESET);
if (aCount > 0)
{
header.SetPayloadMarker();
message->SetPayloadMarker();
}
VerifyOrExit((message = netif.GetCoap().NewMessage(header)) != NULL, error = OT_ERROR_NO_BUFS);
if (aCount > 0)
{
TypeListTlv tlv;
@@ -652,19 +631,13 @@ exit:
return error;
}
void NetworkDiagnostic::HandleDiagnosticReset(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticReset(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<NetworkDiagnostic *>(aContext)->HandleDiagnosticReset(
*static_cast<Coap::Header *>(aHeader), *static_cast<Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
*static_cast<Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticReset(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
void NetworkDiagnostic::HandleDiagnosticReset(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetif & netif = GetNetif();
uint16_t offset = 0;
@@ -673,7 +646,7 @@ void NetworkDiagnostic::HandleDiagnosticReset(Coap::Header & aHeader,
otLogInfoNetDiag("Received diagnostic reset request");
VerifyOrExit(aHeader.GetType() == OT_COAP_TYPE_CONFIRMABLE && aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit((aMessage.Read(aMessage.GetOffset(), sizeof(NetworkDiagnosticTlv), &networkDiagnosticTlv) ==
sizeof(NetworkDiagnosticTlv)));
@@ -701,7 +674,7 @@ void NetworkDiagnostic::HandleDiagnosticReset(Coap::Header & aHeader,
}
}
SuccessOrExit(netif.GetCoap().SendEmptyAck(aHeader, aMessageInfo));
SuccessOrExit(netif.GetCoap().SendEmptyAck(aMessage, aMessageInfo));
otLogInfoNetDiag("Sent diagnostic reset acknowledgment");
src/core/thread/network_diagnostic.hpp
+9 -25
View File
@@ -104,39 +104,23 @@ private:
void FillMacCountersTlv(MacCountersTlv &aMacCountersTlv);
otError FillRequestedTlvs(Message &aRequest, Message &aResponse, NetworkDiagnosticTlv &aNetworkDiagnosticTlv);
static void HandleDiagnosticGetRequest(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetRequest(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticGetRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticGetQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetQuery(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticGetQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticGetResponse(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo,
otError aResult);
void HandleDiagnosticGetResponse(Coap::Header & aHeader,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo,
otError aResult);
void HandleDiagnosticGetResponse(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo, otError aResult);
static void HandleDiagnosticGetAnswer(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetAnswer(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticGetAnswer(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleDiagnosticGetAnswer(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticReset(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleDiagnosticReset(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleDiagnosticReset(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleDiagnosticReset(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Coap::Resource mDiagnosticGetRequest;
Coap::Resource mDiagnosticGetQuery;
src/core/thread/panid_query_server.cpp
+13 -18
View File
@@ -37,7 +37,7 @@
#include <openthread/platform/random.h>
#include "coap/coap_header.hpp"
#include "coap/coap_message.hpp"
#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/instance.hpp"
@@ -60,23 +60,19 @@ PanIdQueryServer::PanIdQueryServer(Instance &aInstance)
GetNetif().GetCoap().AddResource(mPanIdQuery);
}
void PanIdQueryServer::HandleQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
void PanIdQueryServer::HandleQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PanIdQueryServer *>(aContext)->HandleQuery(*static_cast<Coap::Header *>(aHeader),
*static_cast<Message *>(aMessage),
static_cast<PanIdQueryServer *>(aContext)->HandleQuery(*static_cast<Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(aMessageInfo));
}
void PanIdQueryServer::HandleQuery(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void PanIdQueryServer::HandleQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
MeshCoP::PanIdTlv panId;
MeshCoP::ChannelMaskTlv channelMask;
Ip6::MessageInfo responseInfo(aMessageInfo);
VerifyOrExit(aHeader.GetCode() == OT_COAP_CODE_POST);
VerifyOrExit(aMessage.GetCode() == OT_COAP_CODE_POST);
SuccessOrExit(MeshCoP::Tlv::GetTlv(aMessage, MeshCoP::Tlv::kChannelMask, sizeof(channelMask), channelMask));
VerifyOrExit(channelMask.IsValid() && channelMask.GetChannelPage() == OT_RADIO_CHANNEL_PAGE);
@@ -89,9 +85,9 @@ void PanIdQueryServer::HandleQuery(Coap::Header &aHeader, Message &aMessage, con
mPanId = panId.GetPanId();
mTimer.Start(kScanDelay);
if (aHeader.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aHeader, responseInfo));
SuccessOrExit(GetNetif().GetCoap().SendEmptyAck(aMessage, responseInfo));
otLogInfoMeshCoP("sent panid query response");
}
@@ -127,18 +123,17 @@ otError PanIdQueryServer::SendConflict(void)
{
ThreadNetif & netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::ChannelMaskTlv channelMask;
MeshCoP::PanIdTlv panId;
Ip6::MessageInfo messageInfo;
Message * message;
Coap::Message * message;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_PANID_CONFLICT);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), header)) != NULL, error = OT_ERROR_NO_BUFS);
message->Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
message->SetToken(Coap::Message::kDefaultTokenLength);
message->AppendUriPathOptions(OT_URI_PATH_PANID_CONFLICT);
message->SetPayloadMarker();
channelMask.Init();
channelMask.SetChannelPage(OT_RADIO_CHANNEL_PAGE);
src/core/thread/panid_query_server.hpp
+2 -5
View File
@@ -63,11 +63,8 @@ private:
kScanDelay = 1000, ///< SCAN_DELAY (milliseconds)
};
static void HandleQuery(void * aContext,
otCoapHeader * aHeader,
otMessage * aMessage,
const otMessageInfo *aMessageInfo);
void HandleQuery(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
void HandleQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleScanResult(void *aContext, Mac::Frame *aFrame);
void HandleScanResult(Mac::Frame *aFrame);
src/core/thread/thread_netif.cpp
+1 -1
View File
@@ -196,7 +196,7 @@ exit:
return error;
}
otError ThreadNetif::TmfFilter(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext)
otError ThreadNetif::TmfFilter(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext)
{
OT_UNUSED_VARIABLE(aMessage);
src/core/thread/thread_netif.hpp
+1 -1
View File
@@ -440,7 +440,7 @@ public:
bool IsTmfMessage(const Ip6::MessageInfo &aMessageInfo);
private:
static otError TmfFilter(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext);
static otError TmfFilter(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext);
Coap::Coap mCoap;
#if OPENTHREAD_ENABLE_DHCP6_CLIENT