Symbols ![]()
loading...
Files ![]()
loading...
ot::Coap::Message class
Implements CoAP message generation and parsing.
Syntax
class Message : public ot::Message
{
friend class Option;
friend class MessageQueue;
public:
static constexpr uint8_t kDefaultTokenLength = OT_COAP_DEFAULT_TOKEN_LENGTH;
static constexpr uint8_t kMaxReceivedUriPath = 32;
static constexpr uint8_t kMaxTokenLength = OT_COAP_MAX_TOKEN_LENGTH;
typedef ot::Coap::Type Type;
typedef ot::Coap::Code Code;
enum BlockType : uint8_t
{
kBlockType1 = 1,
kBlockType2 = 2,
};
static constexpr uint8_t kBlockSzxBase = 4;
void Init(void);
void Init(Type aType, Code aCode);
Error Init(Type aType, Code aCode, Uri aUri);
Error InitAsPost(const Ip6::Address &aDestination, Uri aUri);
void Finish(void);
uint8_t GetVersion(void) const
{
return (GetHelpData().mHeader.mVersionTypeToken & kVersionMask) >> kVersionOffset;
}
void SetVersion(uint8_t aVersion)
{
GetHelpData().mHeader.mVersionTypeToken &= ~kVersionMask;
GetHelpData().mHeader.mVersionTypeToken |= aVersion << kVersionOffset;
}
uint8_t GetType(void) const { return (GetHelpData().mHeader.mVersionTypeToken & kTypeMask) >> kTypeOffset; }
void SetType(Type aType)
{
GetHelpData().mHeader.mVersionTypeToken &= ~kTypeMask;
GetHelpData().mHeader.mVersionTypeToken |= (static_cast<uint8_t>(aType) << kTypeOffset);
}
uint8_t GetCode(void) const { return static_cast<Code>(GetHelpData().mHeader.mCode); }
void SetCode(Code aCode) { GetHelpData().mHeader.mCode = static_cast<uint8_t>(aCode); }
#if OPENTHREAD_CONFIG_COAP_API_ENABLE
const char *CodeToString(void) const;
#endif
uint16_t GetMessageId(void) const { return BigEndian::HostSwap16(GetHelpData().mHeader.mMessageId); }
void SetMessageId(uint16_t aMessageId) { GetHelpData().mHeader.mMessageId = BigEndian::HostSwap16(aMessageId); }
uint8_t GetTokenLength(void) const
{
return (GetHelpData().mHeader.mVersionTypeToken & kTokenLengthMask) >> kTokenLengthOffset;
}
const uint8_t *GetToken(void) const { return GetHelpData().mHeader.mToken; }
Error SetToken(const uint8_t *aToken, uint8_t aTokenLength);
Error SetTokenFromMessage(const Message &aMessage);
Error GenerateRandomToken(uint8_t aTokenLength);
bool IsTokenEqual(const Message &aMessage) const;
Error AppendOption(uint16_t aNumber, uint16_t aLength, const void *aValue);
Error AppendOptionFromMessage(uint16_t aNumber, uint16_t aLength, const Message &aMessage, uint16_t aOffset);
Error AppendUintOption(uint16_t aNumber, uint32_t aValue);
Error AppendStringOption(uint16_t aNumber, const char *aValue);
Error AppendObserveOption(uint32_t aObserve) { return AppendUintOption(kOptionObserve, aObserve & kObserveMask); }
Error AppendUriPathOptions(const char *aUriPath);
Error ReadUriPathOptions(char (&aUriPath)[kMaxReceivedUriPath + 1]) const;
Error AppendUriQueryOptions(const char *aUriQuery);
Error AppendBlockOption(BlockType aType, uint32_t aNum, bool aMore, otCoapBlockSzx aSize);
Error AppendProxyUriOption(const char *aProxyUri) { return AppendStringOption(kOptionProxyUri, aProxyUri); }
Error AppendContentFormatOption(otCoapOptionContentFormat aContentFormat)
{
return AppendUintOption(kOptionContentFormat, static_cast<uint32_t>(aContentFormat));
}
Error AppendMaxAgeOption(uint32_t aMaxAge) { return AppendUintOption(kOptionMaxAge, aMaxAge); }
Error AppendUriQueryOption(const char *aUriQuery) { return AppendStringOption(kOptionUriQuery, aUriQuery); }
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
Error ReadBlockOptionValues(uint16_t aBlockType);
uint16_t GetHeaderLength(void) const { return GetHelpData().mHeaderLength; }
uint32_t GetBlockWiseBlockNumber(void) const { return GetHelpData().mBlockWiseData.mBlockNumber; }
bool IsMoreBlocksFlagSet(void) const { return GetHelpData().mBlockWiseData.mMoreBlocks; }
otCoapBlockSzx GetBlockWiseBlockSize(void) const { return GetHelpData().mBlockWiseData.mBlockSize; }
#endif
Error GetUriPath(char *aUriPath) const;
Error SetPayloadMarker(void);
uint16_t GetOptionStart(void) const { return kMinHeaderLength + GetTokenLength(); }
Error ParseHeader(void);
Error SetDefaultResponseHeader(const Message &aRequest);
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
void SetBlockWiseBlockNumber(uint32_t aBlockNumber) { GetHelpData().mBlockWiseData.mBlockNumber = aBlockNumber; }
void SetMoreBlocksFlag(bool aMoreBlocks) { GetHelpData().mBlockWiseData.mMoreBlocks = aMoreBlocks; }
void SetBlockWiseBlockSize(otCoapBlockSzx aBlockSize) { GetHelpData().mBlockWiseData.mBlockSize = aBlockSize; }
#endif
bool IsEmpty(void) const { return (GetCode() == kCodeEmpty); }
bool IsRequest(void) const { return (GetCode() >= kCodeGet) && (GetCode() <= kCodeDelete); }
bool IsGetRequest(void) const { return GetCode() == kCodeGet; }
bool IsPostRequest(void) const { return GetCode() == kCodePost; }
bool IsPutRequest(void) const { return GetCode() == kCodePut; }
bool IsDeleteRequest(void) const { return GetCode() == kCodeDelete; }
bool IsResponse(void) const { return GetCode() >= OT_COAP_CODE_RESPONSE_MIN; }
bool IsConfirmable(void) const { return (GetType() == kTypeConfirmable); }
bool IsNonConfirmable(void) const { return (GetType() == kTypeNonConfirmable); }
bool IsAck(void) const { return (GetType() == kTypeAck); }
bool IsReset(void) const { return (GetType() == kTypeReset); }
bool IsConfirmablePostRequest(void) const;
bool IsNonConfirmablePostRequest(void) const;
Message *Clone(uint16_t aLength) const;
Message *Clone(void) const { return Clone(GetLength()); }
static uint16_t GetHelpDataReserved(void) { return sizeof(HelpData) + kHelpDataAlignment; }
Message *GetNextCoapMessage(void) { return static_cast<Message *>(GetNext()); }
const Message *GetNextCoapMessage(void) const { return static_cast<const Message *>(GetNext()); }
private:
static constexpr uint8_t kVersionOffset = 6;
static constexpr uint8_t kVersionMask = 0x3 << kVersionOffset;
static constexpr uint8_t kVersion1 = 1;
static constexpr uint8_t kTypeOffset = 4;
static constexpr uint8_t kTypeMask = 0x3 << kTypeOffset;
static constexpr uint8_t kTokenLengthOffset = 0;
static constexpr uint8_t kTokenLengthMask = 0xf << kTokenLengthOffset;
static constexpr uint8_t kOptionDeltaOffset = 4;
static constexpr uint8_t kOptionDeltaMask = 0xf << kOptionDeltaOffset;
static constexpr uint8_t kOptionLengthOffset = 0;
static constexpr uint8_t kOptionLengthMask = 0xf << kOptionLengthOffset;
static constexpr uint8_t kMaxOptionHeaderSize = 5;
static constexpr uint8_t kOption1ByteExtension = 13;
static constexpr uint8_t kOption2ByteExtension = 14;
static constexpr uint8_t kPayloadMarker = 0xff;
static constexpr uint8_t kHelpDataAlignment = sizeof(uint16_t);
static constexpr uint16_t kMinHeaderLength = 4;
static constexpr uint16_t kMaxHeaderLength = 512;
static constexpr uint16_t kOption1ByteExtensionOffset = 13;
static constexpr uint16_t kOption2ByteExtensionOffset = 269;
static constexpr uint8_t kBlockSzxOffset = 0;
static constexpr uint8_t kBlockMOffset = 3;
static constexpr uint8_t kBlockNumOffset = 4;
static constexpr uint32_t kObserveMask = 0xffffff;
static constexpr uint32_t kBlockNumMax = 0xffff;
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
struct BlockWiseData
{
uint32_t mBlockNumber;
bool mMoreBlocks;
otCoapBlockSzx mBlockSize;
};
#endif
OT_TOOL_PACKED_BEGIN
struct Header
{
uint8_t mVersionTypeToken;
uint8_t mCode;
uint16_t mMessageId;
uint8_t mToken[kMaxTokenLength];
} OT_TOOL_PACKED_END;
struct HelpData : public Clearable<HelpData>
{
Header mHeader;
uint16_t mOptionLast;
uint16_t mHeaderOffset;
uint16_t mHeaderLength;
bool mPayloadMarkerSet;
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
BlockWiseData mBlockWiseData;
#endif
};
class ConstIterator : public ot::Message::ConstIterator
{
public:
using ot::Message::ConstIterator::ConstIterator;
const Message &operator*(void) { return static_cast<const Message &>(ot::Message::ConstIterator::operator*()); }
const Message *operator->(void)
{
return static_cast<const Message *>(ot::Message::ConstIterator::operator->());
}
};
class Iterator : public ot::Message::Iterator
{
public:
using ot::Message::Iterator::Iterator;
Message &operator*(void) { return static_cast<Message &>(ot::Message::Iterator::operator*()); }
Message *operator->(void) { return static_cast<Message *>(ot::Message::Iterator::operator->()); }
};
static_assert(sizeof(HelpData) <= sizeof(Ip6::Header) + sizeof(Ip6::HopByHopHeader) + sizeof(Ip6::MplOption) +
sizeof(Ip6::Udp::Header),
"HelpData size exceeds the size of the reserved region in the message");
const HelpData &GetHelpData(void) const
{
static_assert(sizeof(HelpData) + kHelpDataAlignment <= kHeadBufferDataSize,
"Insufficient buffer size for CoAP processing! Increase OPENTHREAD_CONFIG_MESSAGE_BUFFER_SIZE.");
return *static_cast<const HelpData *>(OT_ALIGN(GetFirstData(), kHelpDataAlignment));
}
HelpData &GetHelpData(void) { return AsNonConst(AsConst(this)->GetHelpData()); }
uint8_t *GetToken(void) { return GetHelpData().mHeader.mToken; }
void SetTokenLength(uint8_t aTokenLength)
{
GetHelpData().mHeader.mVersionTypeToken &= ~kTokenLengthMask;
GetHelpData().mHeader.mVersionTypeToken |= ((aTokenLength << kTokenLengthOffset) & kTokenLengthMask);
}
uint8_t WriteExtendedOptionField(uint16_t aValue, uint8_t *&aBuffer);
Error AppendOptionHeader(uint16_t aNumber, uint16_t aLength);
};
Fields
Field
Related Functions
Found 94 other functions taking a Message
argument:
Function
Description
Initializes the iterator to iterate over CoAP Options in a CoAP message. The iterator MUST be initialized before any other methods are used, otherwise its behavior is undefined. After initialization, the iterator is either updated to point to the first option, or it is marked as done (i.e., `IsDone()` returns `true`) when there is no option or if there is a parse error.
Sends a CoAP message with custom transmission parameters. If a response for a request is expected, respective function and context information should be provided. If no response is expected, these arguments should be `nullptr` pointers. If Message ID was not set in the header (equal to 0), this method will assign unique Message ID to the message.
Adds a message to the end of the queue.
Sets the Token value and length by copying it from another given message.
Removes a message from the queue.
Removes a message from the queue and frees it.
Sends a CoAP ACK message on which a dummy CoAP response is piggybacked.
Sends a CoAP message over secure DTLS connection. If a response for a request is expected, respective function and context information should be provided. If no response is expected, these arguments should be nullptr pointers. If Message Id was not set in the header (equal to 0), this function will assign unique Message Id to the message.
Gets the next Network Diagnostic TLV in a given message.
Checks if Tokens in two CoAP headers are equal.
Sets a default response header based on request header.
Sends a CoAP reset message.
Sends header-only CoAP response message.
Processes a MGMT_GET request message and prepares the response.
Sends a CoAP ACK empty message which is used in Separate Response for confirmable requests.
Sends a header-only CoAP message to indicate no resource matched for the request.
Processes a MGMT_COMMISSIONER_GET request message and prepares the response.
Appends a CoAP option reading Option value from another or potentially the same message.
Adds a given response to the cache. If matching response (the same Message ID, source endpoint address and port) exists in the cache given response is not added. The CoAP response is copied before it is added to the cache.
Gets a copy of CoAP response from the cache that matches a given Message ID and source endpoint.
Allocates and initializes a new CoAP response message with Network Control priority level for a given request message. The CoAP header is initialized as `kTypeAck` with `kCodeChanged`. The token and message ID is copied from @p aRequest. This method also sets the payload marker (calling `SetPayloadMarker()`). Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and remove the payload marker when there is no payload.
Allocates and initializes a new CoAP response message with regular priority level for a given request message. The CoAP header is initialized as `kTypeAck` with `kCodeChanged`. The token and message ID is copied from @p aRequest. This method also sets the payload marker (calling `SetPayloadMarker()`). Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and remove the payload marker when there is no payload.