coap_reader.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/coap_constants.h>
#include <satcat5/io_readable.h>
#include <satcat5/utils.h>
 
// Maximum length of an assembled Uri-Path string, ignoring other Uri- options
// and an implicit leading /. Example: 'resource1/resource2/res3'
#ifndef SATCAT5_COAP_MAX_URI_PATH_LEN
#define SATCAT5_COAP_MAX_URI_PATH_LEN 64
#endif
 
namespace satcat5 {
    namespace coap {
        class Option final : public satcat5::io::LimitedRead {
        public:
            u16 id() const     { return m_id; }
            u16 len() const    { return m_len; }
 
            unsigned value_str(char* dst);
            u64 value_uint();
 
            bool is_critical() const    { return m_id & 0x0001; }
            bool is_unsafe() const      { return m_id & 0x0002; }
            bool no_cache_key() const   { return (m_id & 0x001E) == 0x001C; }
 
        private:
            // These methods should only be accessed by coap::ReadHeader.
            friend satcat5::coap::ReadHeader;
            constexpr explicit Option(satcat5::io::Readable* src)
                : LimitedRead(src, 0), m_id(0), m_len(0) {}
            inline Option* reset(unsigned len)
                { m_len = len; read_reset(len); return this; }
            u16 m_id, m_len;
        };
 
        class ReadHeader {
        public:
            explicit ReadHeader(satcat5::io::Readable* src);
 
            // Forbid unsafe assignment and copy operators.
            ReadHeader(const ReadHeader&) = delete;
            ReadHeader& operator=(const ReadHeader&) = delete;
 
            bool next_option();
 
            satcat5::io::Readable* read_data();
 
            inline void read_finalize()
                { m_src->read_finalize(); }
 
            // Accessors for the message header and parsing state.
            inline bool error() const               
                { return m_state == State::ERROR; }
            inline Code error_code() const          
                { return m_error_code; }
            inline const char* error_msg() const    
                { return m_error_msg; }
            inline u8 version() const               
                { return m_type & 0xC0; }
            inline u8 type() const                  
                { return m_type & 0x30; }
            inline u8 tkl() const                   
                { return m_type & 0x0F; }
            inline Code code() const                
                { return m_code; }
            inline u16 msg_id() const               
                { return m_id; }
            inline u64 token() const                
                { return m_token; }
            inline bool is_request() const          
                { return type() == TYPE_CON || type() == TYPE_NON; }
            inline bool is_response() const         
                { return type() == TYPE_ACK; }
            inline satcat5::coap::Option& option()  
                { return m_opt;}
 
        protected:
            enum class State {OPTIONS, DATA, ERROR};
 
            u16 read_var_int(u8 nybb);
 
            inline void set_error(Code code, const char* msg = "")
                { m_state = State::ERROR; m_error_code = code; m_error_msg = msg; }
 
            satcat5::io::Readable* const m_src;
 
            // Reader state and error information if triggered.
            State m_state;                  
            Code m_error_code;              
            const char* m_error_msg;        
 
            // Header fields
            const u8 m_type;                
            satcat5::coap::Code m_code;     
            const u16 m_id;                 
            u64 m_token;                    
 
            satcat5::coap::Option m_opt;
        };
 
        class Reader : public satcat5::coap::ReadHeader {
        public:
            explicit Reader(satcat5::io::Readable* src);
 
            // Forbid unsafe assignment and copy operators.
            Reader(const Reader&) = delete;
            Reader& operator=(const Reader&) = delete;
 
            inline satcat5::util::optional<const char*> uri_path() const // Uri-Path
                { return m_uri_path_wridx == 0 ?
                    satcat5::util::optional<const char*>() : m_uri_path; }
            inline satcat5::util::optional<u16> format() const  // Content-Format
                { return m_format; }
            inline satcat5::util::optional<u64> size1() const   // Size1
                { return m_size1; }
            inline satcat5::util::optional<u64> block() const   // Block1 & Block2 combined
                { return m_block1 ? m_block1 : m_block2; }      // TODO: Deprecate these?
            inline u16 block_size() const
                { return m_block1 ? block1_size() : block2_size(); }
            inline bool block_more() const
                { return m_block1 ? block1_more() : block2_more(); }
            inline u32 block_num() const
                { return m_block1 ? block1_num() : block2_num(); }
            inline satcat5::util::optional<u64> block1() const  // Block1 only
                { return m_block1; }
            inline u16 block1_size() const
                { return 1 << ((m_block1.value() & 0x7) + 4); }
            inline bool block1_more() const
                { return (m_block1.value() & 0x8) >> 3; }
            inline u32 block1_num() const
                { return (m_block1.value() & 0xFFFFFFF0) >> 4; }
            inline satcat5::util::optional<u64> block2()        // Block2 only
                { return m_block2; }
            inline u16 block2_size() const
                { return 1 << ((m_block2.value() & 0x7) + 4); }
            inline bool block2_more() const
                { return (m_block2.value() & 0x8) >> 3; }
            inline u32 block2_num() const
                { return (m_block2.value() & 0xFFFFFFF0) >> 4; }
 
        protected:
            void append_uri_path();
 
            void read_options();
 
            virtual void read_user_option() = 0;
 
            char m_uri_path[SATCAT5_COAP_MAX_URI_PATH_LEN + 1];
            unsigned m_uri_path_wridx;              
            satcat5::util::optional<u16> m_format;  
            satcat5::util::optional<u64> m_block1;  
            satcat5::util::optional<u64> m_block2;  
            satcat5::util::optional<u64> m_size1;   
        };
 
        class ReadSimple final : public satcat5::coap::Reader {
        public:
            explicit ReadSimple(satcat5::io::Readable* src)
                : Reader(src) { read_options(); }
 
        protected:
            void read_user_option() override;
        };
    }
}