ot::Coap::Option class

class Option; enum Type : uint8_t { kTypeConfirmable = OT_COAP_TYPE_CONFIRMABLE, kTypeNonConfirmable = OT_COAP_TYPE_NON_CONFIRMABLE, kTypeAck = OT_COAP_TYPE_ACKNOWLEDGMENT, kTypeReset = OT_COAP_TYPE_RESET, }; enum Code : uint8_t { kCodeEmpty = OT_COAP_CODE_EMPTY, kCodeGet = OT_COAP_CODE_GET, kCodePost = OT_COAP_CODE_POST, kCodePut = OT_COAP_CODE_PUT, kCodeDelete = OT_COAP_CODE_DELETE, kCodeResponseMin = OT_COAP_CODE_RESPONSE_MIN, kCodeCreated = OT_COAP_CODE_CREATED, kCodeDeleted = OT_COAP_CODE_DELETED, kCodeValid = OT_COAP_CODE_VALID, kCodeChanged = OT_COAP_CODE_CHANGED, kCodeContent = OT_COAP_CODE_CONTENT, kCodeContinue = OT_COAP_CODE_CONTINUE, kCodeBadRequest = OT_COAP_CODE_BAD_REQUEST, kCodeUnauthorized = OT_COAP_CODE_UNAUTHORIZED, kCodeBadOption = OT_COAP_CODE_BAD_OPTION, kCodeForbidden = OT_COAP_CODE_FORBIDDEN, kCodeNotFound = OT_COAP_CODE_NOT_FOUND, kCodeMethodNotAllowed = OT_COAP_CODE_METHOD_NOT_ALLOWED, kCodeNotAcceptable = OT_COAP_CODE_NOT_ACCEPTABLE, kCodeRequestIncomplete = OT_COAP_CODE_REQUEST_INCOMPLETE, kCodePreconditionFailed = OT_COAP_CODE_PRECONDITION_FAILED, kCodeRequestTooLarge = OT_COAP_CODE_REQUEST_TOO_LARGE, kCodeUnsupportedFormat = OT_COAP_CODE_UNSUPPORTED_FORMAT, kCodeInternalError = OT_COAP_CODE_INTERNAL_ERROR, kCodeNotImplemented = OT_COAP_CODE_NOT_IMPLEMENTED, kCodeBadGateway = OT_COAP_CODE_BAD_GATEWAY, kCodeServiceUnavailable = OT_COAP_CODE_SERVICE_UNAVAILABLE, kCodeGatewayTimeout = OT_COAP_CODE_GATEWAY_TIMEOUT, kCodeProxyNotSupported = OT_COAP_CODE_PROXY_NOT_SUPPORTED, }; enum OptionNumber : uint16_t { kOptionIfMatch = OT_COAP_OPTION_IF_MATCH, kOptionUriHost = OT_COAP_OPTION_URI_HOST, kOptionETag = OT_COAP_OPTION_E_TAG, kOptionIfNoneMatch = OT_COAP_OPTION_IF_NONE_MATCH, kOptionObserve = OT_COAP_OPTION_OBSERVE, kOptionUriPort = OT_COAP_OPTION_URI_PORT, kOptionLocationPath = OT_COAP_OPTION_LOCATION_PATH, kOptionUriPath = OT_COAP_OPTION_URI_PATH, kOptionContentFormat = OT_COAP_OPTION_CONTENT_FORMAT, kOptionMaxAge = OT_COAP_OPTION_MAX_AGE, kOptionUriQuery = OT_COAP_OPTION_URI_QUERY, kOptionAccept = OT_COAP_OPTION_ACCEPT, kOptionLocationQuery = OT_COAP_OPTION_LOCATION_QUERY, kOptionBlock2 = OT_COAP_OPTION_BLOCK2, kOptionBlock1 = OT_COAP_OPTION_BLOCK1, kOptionSize2 = OT_COAP_OPTION_SIZE2, kOptionProxyUri = OT_COAP_OPTION_PROXY_URI, kOptionProxyScheme = OT_COAP_OPTION_PROXY_SCHEME, kOptionSize1 = OT_COAP_OPTION_SIZE1, }; 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); }; class MessageQueue : public ot::MessageQueue { public: MessageQueue(void) = default; Message *GetHead(void) { return static_cast<Message *>(ot::MessageQueue::GetHead()); } const Message *GetHead(void) const { return static_cast<const Message *>(ot::MessageQueue::GetHead()); } void Enqueue(Message &aMessage) { Enqueue(aMessage, kQueuePositionTail); } void Enqueue(Message &aMessage, QueuePosition aPosition) { ot::MessageQueue::Enqueue(aMessage, aPosition); } void Dequeue(Message &aMessage) { ot::MessageQueue::Dequeue(aMessage); } void DequeueAndFree(Message &aMessage) { ot::MessageQueue::DequeueAndFree(aMessage); } Message::Iterator begin(void); Message::Iterator end(void) { return Message::Iterator(); } Message::ConstIterator begin(void) const; Message::ConstIterator end(void) const { return Message::ConstIterator(); } }; class Option : public otCoapOption;