ProsecCoAP.h

Go to the documentation of this file.

 
#ifndef __PROSECCOAP_H__
#define __PROSECCOAP_H__
 
// Include common types and definitions.
#include "Definitions.h"
 
// Include public utility helpers.
#include "Utils.h"
 
// Include internal implementation details.
#include "detail/Detail.h"
 
// Include Observers management functionality.
#include "observers/Observers.h"
 
namespace Coap
{
 
    // SECTION Functions.
    ErrorCode getRandomToken(size_t length, uint8_t *buffer);
 
 // End of Functions group
    // !SECTION End of Functions.
 
    struct Option
    {
        OptionNumber number;
        const uint8_t *value;
        size_t length;
 
        Option() : number(static_cast<OptionNumber>(0)), value(nullptr), length(0) {}
        Option(OptionNumber number, const uint8_t *value, size_t length)
            : number(number), value(value), length(length) {}
    };
 
    class OptionIterator
    {
 
        // Give access to private members to Message methods.
        friend class Message;
        const Message &_message;
        size_t _currentByte;
        uint16_t _currentOptionNumber;
 
    public:
        OptionIterator(const Message &message);
 
        ErrorCode next(Option &option);
    };
 
    class Message
    {
    private:
        uint8_t _message[COAP_MAX_MESSAGE_SIZE];
        size_t _messageLength;
        ErrorCode _insert(size_t startPosition, const uint8_t *data, size_t length);
 
        ErrorCode _remove(size_t startPosition, size_t length);
 
        static uint16_t _getNextId();
 
        void _setId(uint16_t id);
 
    public:
        Message() : Message(MessageType::NON, MessageCode::EMPTY) {}
 
        Message(MessageType type, MessageCode code) : Message(type, code, _getNextId()) {}
 
        Message(MessageType type, MessageCode code, uint16_t id);
 
        const uint8_t *asRaw() const
        {
            return this->_message;
        }
 
        static ErrorCode fromUdp(UDP *udp, Message &message);
 
        ErrorCode buildResponse(MessageCode code, Message &response) const;
 
        uint8_t getVersion() const
        {
            return (this->_message[0] >> 6) & 0x03;
        }
 
        size_t getLength() const
        {
            return this->_messageLength;
        }
 
        void setType(MessageType type);
 
        MessageType getType() const;
 
        void setCode(MessageCode code);
        MessageCode getCode() const;
 
        uint16_t getId() const;
 
        size_t getTokenLength() const;
 
        ErrorCode setToken(const uint8_t *token, size_t length);
 
        ErrorCode addRandomToken(size_t length);
 
        const uint8_t *getToken() const;
 
        bool matchesToken(const uint8_t *token, size_t length) const;
 
        OptionIterator getOptionIterator() const;
        ErrorCode addOption(OptionNumber number, const uint8_t *value, size_t length);
 
        ErrorCode addOption(Option option)
        {
            return this->addOption(option.number, option.value, option.length);
        };
 
        ErrorCode addHost(IPAddress ip);
 
        ErrorCode addPort(uint16_t port);
 
        ErrorCode addPath(const char *path);
 
        ErrorCode getPath(String *path) const;
 
        ErrorCode getPayload(const uint8_t *&payload, size_t &length) const;
 
        ErrorCode addPayload(const uint8_t *payload, size_t length);
 
        ErrorCode addPayload(const uint8_t *payload, size_t length, ContentFormat format);
 
        ErrorCode getObserveValue(uint32_t &observeValue);
 
        bool isObserveRegister();
 
        bool isObserveDeregister();
 
        ErrorCode buildNotification(Observer &observer, Message &notification) const;
    };
 
    class Node; // Forward declaration.
 
    namespace Detail
    {
        struct RetransmissionEntry
        {
            Coap::Message message;
            unsigned short attempts = COAP_MAX_RETRANSMIT;
            unsigned long timeoutBaseInterval = COAP_ACK_MAX_TIMEOUT_MS;
            unsigned long nextAttemptDeadline = 0;
            IPAddress ip;
            uint16_t port = 0;
 
            RetransmissionEntry() = default;
 
            void set(Coap::Message message, IPAddress ip, uint16_t port);
 
            bool isEmpty() const
            {
                return this->attempts >= COAP_MAX_RETRANSMIT;
            }
 
            unsigned long getDeadline() const
            {
                return this->nextAttemptDeadline;
            }
 
            void setAsCompleted()
            {
                this->attempts = COAP_MAX_RETRANSMIT;
            }
 
            ErrorCode retransmit(UDP *udp);
        };
 
        class RetransmissionQueue
        {
        private:
            RetransmissionEntry _entries[COAP_CONFIRMABLE_MESSAGE_QUEUE_SIZE];
 
        public:
            RetransmissionQueue() = default;
 
            ErrorCode add(const Coap::Message &message, IPAddress ip, uint16_t port);
 
            ErrorCode process(UDP *udp);
 
            void matchResponse(const Coap::Message &response);
        };
    }
 
    class Node
    {
    private:
        UDP *_udp;
        uint16_t _port;
        Callback _responseHandler;
        Detail::UriRegistry _serverRegistry;
        Detail::RetransmissionQueue _retransmissionQueue;
 
    public:
        Node(UDP &udp) : Node(udp, COAP_DEFAULT_PORT) {}
 
        Node(UDP &udp, uint16_t port) : _udp(&udp), _port(port), _responseHandler(nullptr), _retransmissionQueue() {}
 
        uint16_t getPort() const
        {
            return this->_port;
        }
 
        ErrorCode start();
 
        void setResponseHandler(Callback handler) { _responseHandler = handler; }
 
        ErrorCode serve(const char *path, Callback callback);
 
        ErrorCode loop();
 
        ErrorCode sendMessage(const Message &message, IPAddress ip, uint16_t port);
    };
 
} // End of namespace Coap
 
#endif