MemoryConfig.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_MEMORYCONFIG_HXX_
#define _OPENLCB_MEMORYCONFIG_HXX_
 
#include "openlcb/DatagramDefs.hxx"
#include "openlcb/DatagramHandlerDefault.hxx"
#include "openlcb/MemoryConfigDefs.hxx"
#include "openmrn_features.h"
#include "utils/ConfigUpdateService.hxx"
#include "utils/Destructable.hxx"
 
class Notifiable;
 
extern "C" {
extern void enter_bootloader();
#if OPENMRN_FEATURE_REBOOT
extern void reboot();
#endif
}
 
namespace openlcb
{
 
class MemorySpace : public Destructable
{
public:
    typedef uint32_t address_t;
    typedef uint16_t errorcode_t;
 
    static const errorcode_t ERROR_AGAIN = 0x3FFF;
 
    virtual bool set_node(Node* node)
    {
        return true;
    }
 
    virtual bool read_only()
    {
        return true;
    }
    virtual address_t min_address()
    {
        return 0;
    }
    virtual address_t max_address() = 0;
 
    virtual size_t write(address_t destination, const uint8_t *data, size_t len,
                         errorcode_t *error, Notifiable *again)
    {
        DIE("Unimplemented");
    }
    virtual size_t read(address_t source, uint8_t *dst, size_t len,
                        errorcode_t *error, Notifiable *again) = 0;
 
    virtual errorcode_t freeze() {
        return Defs::ERROR_INVALID_ARGS;
    }
 
    virtual errorcode_t unfreeze() {
        return Defs::ERROR_INVALID_ARGS;
    }
};
 
class ReadOnlyMemoryBlock : public MemorySpace
{
public:
    ReadOnlyMemoryBlock(const void *data)
        : data_(reinterpret_cast<const uint8_t *>(data))
        , len_(strlen((const char*)data_))
    {
    }
 
    ReadOnlyMemoryBlock(const void *data, address_t len)
        : data_(reinterpret_cast<const uint8_t*>(data))
        , len_(len)
    {
    }
 
    address_t max_address() OVERRIDE
    {
        return len_ - 1;
    }
 
    size_t read(address_t source, uint8_t *dst, size_t len, errorcode_t *error,
                Notifiable *again) OVERRIDE
    {
        if (source >= len_) {
            *error = MemoryConfigDefs::ERROR_OUT_OF_BOUNDS;
            return 0;
        }
        size_t count = len;
        if (source + count > len_)
        {
            count = len_ - source;
        }
        memcpy(dst, data_ + source, count);
        return count;
    }
 
private:
    const uint8_t *data_; //< Data bytes to serve.
    const address_t len_; //< Length of block to serve.
};
 
class ReadWriteMemoryBlock : public MemorySpace
{
public:
    ReadWriteMemoryBlock(void *data, address_t len)
        : data_(reinterpret_cast<uint8_t*>(data))
        , len_(len)
    {
    }
 
    bool read_only() OVERRIDE
    {
        return false;
    }
 
    address_t max_address() OVERRIDE
    {
        return len_ - 1;
    }
 
    size_t read(address_t source, uint8_t *dst, size_t len, errorcode_t *error,
                Notifiable *again) OVERRIDE
    {
        if (source >= len_) {
            *error = MemoryConfigDefs::ERROR_OUT_OF_BOUNDS;
            return 0;
        }
        size_t count = len;
        if (source + count > len_)
        {
            count = len_ - source;
        }
        memcpy(dst, data_ + source, count);
        return count;
    }
 
    size_t write(address_t destination, const uint8_t *data, size_t len,
                 errorcode_t *error, Notifiable *again) OVERRIDE {
        if (destination >= len_) {
            *error = MemoryConfigDefs::ERROR_OUT_OF_BOUNDS;
            return 0;
        }
        if (destination + len > len_) {
            len = len_ - destination;
        }
        memcpy(data_ + destination, data, len);
        return len;
    }
 
private:
    uint8_t *data_; //< Data bytes to serve.
    const address_t len_; //< Length of block to serve.
};
 
class FileMemorySpace : public MemorySpace
{
public:
    static const address_t AUTO_LEN = (address_t) - 1;
    static const address_t UNLIMITED_LEN = (address_t) - 2;
 
    FileMemorySpace(int fd, address_t len = AUTO_LEN);
 
    FileMemorySpace(const char *name, address_t len = AUTO_LEN);
 
    bool read_only() OVERRIDE
    {
        return false;
    }
 
    address_t max_address() OVERRIDE
    {
        ensure_file_open();
        return fileSize_;
    }
 
    size_t write(address_t destination, const uint8_t *data, size_t len,
                 errorcode_t *error, Notifiable *again) OVERRIDE;
 
    size_t read(address_t source, uint8_t *dst, size_t len, errorcode_t *error,
                Notifiable *again) OVERRIDE;
 
private:
    void ensure_file_open();
 
    address_t fileSize_;
    const char *name_;
    int fd_;
};
 
class ROFileMemorySpace : public FileMemorySpace {
public:
    ROFileMemorySpace(int fd, address_t len = AUTO_LEN)
        : FileMemorySpace(fd, len) {}
 
    ROFileMemorySpace(const char *name, address_t len = AUTO_LEN)
        : FileMemorySpace(name, len) {}
 
    bool read_only() OVERRIDE
    {
        return true;
    }
};
 
class MemoryConfigHandlerBase : public DefaultDatagramHandler
{
protected:
    enum
    {
        DATAGRAM_ID = DatagramDefs::CONFIGURATION,
    };
 
    MemoryConfigHandlerBase(DatagramService *if_dg)
        : DefaultDatagramHandler(if_dg)
        , responseFlow_(nullptr)
    {
    }
 
    typedef MemorySpace::address_t address_t;
    typedef MemorySpace::errorcode_t errorcode_t;
    typedef TypedNodeHandlerMap<Node, MemorySpace> Registry;
 
    Action ok_response_sent() OVERRIDE
    {
        if (!response_.empty())
        {
            return allocate_and_call(
                STATE(client_allocated), dg_service()->client_allocator());
        }
        else
        {
            release();
            return call_immediately(STATE(cleanup));
        }
    }
 
    Action cleanup()
    {
        HASSERT(!message());
        return exit();
    }
 
    Action client_allocated()
    {
        responseFlow_ =
            full_allocation_result(dg_service()->client_allocator());
        return allocate_and_call(
            dg_service()->iface()->dispatcher(), STATE(send_response_datagram));
    }
 
    Action send_response_datagram()
    {
        auto *b = get_allocation_result(dg_service()->iface()->dispatcher());
        b->set_done(b_.reset(this));
        b->data()->reset(Defs::MTI_DATAGRAM, message()->data()->dst->node_id(),
            message()->data()->src, EMPTY_PAYLOAD);
        b->data()->payload.swap(response_);
        release(); 
        responseFlow_->write_datagram(b);
        return wait_and_call(STATE(response_flow_complete));
    }
 
    Action response_flow_complete()
    {
        if (!(responseFlow_->result() & DatagramClient::OPERATION_SUCCESS))
        {
            LOG(WARNING,
                "MemoryConfig: Failed to send response datagram. error code %x",
                (unsigned)responseFlow_->result());
        }
        dg_service()->client_allocator()->typed_insert(responseFlow_);
        return call_immediately(STATE(cleanup));
    }
 
    bool has_custom_space()
    {
        return !(in_bytes()[1] & ~MemoryConfigDefs::COMMAND_MASK);
    }
 
    int get_space_number()
    {
        const uint8_t *bytes = in_bytes();
        int len = message()->data()->payload.size();
        uint8_t cmd = bytes[1];
        // Handles special memory spaces FD, FE, FF.
        if (!has_custom_space())
        {
            return MemoryConfigDefs::COMMAND_MASK +
                (cmd & ~MemoryConfigDefs::COMMAND_MASK);
        }
        if (len <= 6)
        {
            LOG(WARNING,
                "MemoryConfig: Incoming datagram asked for custom "
                "space but datagram not long enough. command=0x%02x, "
                "length=%d. Source {0x%012" PRIx64 ", %03x}",
                cmd, len, message()->data()->src.id,
                message()->data()->src.alias);
            return -1;
        }
        return bytes[6];
    }
 
    int get_read_length()
    {
        const uint8_t *bytes = in_bytes();
        int len = message()->data()->payload.size();
        int ofs;
        uint8_t cmd = bytes[1];
        // Handles special memory spaces FD, FE, FF.
        if (!has_custom_space())
        {
            ofs = 6;
        }
        else
        {
            ofs = 7;
        }
        if (len <= ofs)
        {
            LOG(WARNING,
                "MemoryConfig::read_len: Incoming datagram not long "
                "enough. command=0x%02x, length=%d. Source "
                "{0x%012" PRIx64 ", %03x}",
                cmd, len, message()->data()->src.id,
                message()->data()->src.alias);
            return -1;
        }
        return bytes[ofs] & 0x7F; // highest bit is reserved.
    }
 
    int get_write_length()
    {
        int len = message()->data()->payload.size();
        return len - (has_custom_space() ? 7 : 6);
    }
 
    address_t get_address()
    {
        const uint8_t *bytes = in_bytes();
        address_t a = bytes[2];
        a <<= 8;
        a |= bytes[3];
        a <<= 8;
        a |= bytes[4];
        a <<= 8;
        a |= bytes[5];
        return a;
    }
 
    void set_address_and_space()
    {
        uint8_t *resp_bytes = out_bytes();
        const uint8_t *bytes = in_bytes();
        memcpy(resp_bytes + 2, bytes + 2, 4);
        if (has_custom_space())
        {
            resp_bytes[6] = bytes[6];
        }
        else
        {
            resp_bytes[1] |= (bytes[1] & ~MemoryConfigDefs::COMMAND_MASK);
        }
    }
 
    void set_address(address_t address)
    {
        uint8_t *bytes = out_bytes();
        bytes[5] = address & 0xff;
        address >>= 8;
        bytes[4] = address & 0xff;
        address >>= 8;
        bytes[3] = address & 0xff;
        address >>= 8;
        bytes[2] = address & 0xff;
    }
 
    uint8_t *out_bytes()
    {
        return reinterpret_cast<uint8_t *>(&response_[0]);
    }
 
    const uint8_t *in_bytes()
    {
        return reinterpret_cast<const uint8_t *>(
            message()->data()->payload.data());
    }
 
    DatagramPayload response_; //< reply payload to send back.
    DatagramClient *responseFlow_;
    BarrierNotifiable b_;
}; // class MemoryConfigHandlerBase
 
class MemoryConfigHandler : public MemoryConfigHandlerBase
{
public:
    MemoryConfigHandler(DatagramService *if_dg, Node *node, int registry_size)
        : MemoryConfigHandlerBase(if_dg)
        , registry_(registry_size)
    {
        dg_service()->registry()->insert(node, DATAGRAM_ID, this);
    }
 
    ~MemoryConfigHandler()
    {
    }
 
    Registry *registry()
    {
        return &registry_;
    }
 
    void send(DefaultDatagramHandler::message_type *message, unsigned priority = UINT_MAX) override
    {
        size_t len = message->data()->payload.size();
        const uint8_t *bytes = (const uint8_t *)message->data()->payload.data();
        uint8_t cmd = ((len >= 2) && (client_ != nullptr)) ? bytes[1] : 0;
        bool is_client_command = false;
        // To recognize replies for read & write commands, we need to look at a
        // bit.
        if ((cmd < MemoryConfigDefs::COMMAND_MAX_FOR_RW) &&
            (cmd & MemoryConfigDefs::COMMAND_REPLY_BIT_FOR_RW))
        {
            is_client_command = true;
        }
        // For the rest of the commands we can enumerate which are replies.
        switch (cmd)
        {
            case MemoryConfigDefs::COMMAND_OPTIONS_REPLY:
            case MemoryConfigDefs::COMMAND_INFORMATION_REPLY:
            case MemoryConfigDefs::COMMAND_LOCK_REPLY:
            case MemoryConfigDefs::COMMAND_UNIQUE_ID_REPLY:
            {
                is_client_command = true;
            }
            default:
                break;
        }
        LOG(VERBOSE, "MemoryConfig incoming cmd 0x%02x is_client %d", cmd,
            is_client_command);
        if (is_client_command)
        {
            client_->send(message, priority);
            return;
        }
        DatagramHandlerFlow::send(message, priority);
    }
 
    void set_client(DatagramHandlerFlow* client) {
        HASSERT(client_ == nullptr || client_ == client);
        client_ = client;
    }
 
    void clear_client(DatagramHandlerFlow* client) {
        HASSERT(client_ == client);
        client_ = nullptr;
    }
 
    void set_stream_handler(DatagramHandlerFlow *stream_handler)
    {
        streamHandler_ = stream_handler;
    }
 
private:
    Action entry() OVERRIDE
    {
        response_.clear();
        const uint8_t *bytes = in_bytes();
        size_t len = message()->data()->payload.size();
        HASSERT(len >= 1);
        HASSERT(bytes[0] == DATAGRAM_ID);
        if (len < 2)
        {
            return respond_reject(Defs::ERROR_INVALID_ARGS_MESSAGE_TOO_SHORT);
        }
 
        uint8_t cmd = bytes[1];
 
        if ((cmd & MemoryConfigDefs::COMMAND_MASK) ==
            MemoryConfigDefs::COMMAND_READ)
        {
            return call_immediately(STATE(handle_read));
        }
        else if ((cmd & MemoryConfigDefs::COMMAND_MASK) ==
                 MemoryConfigDefs::COMMAND_WRITE)
        {
            return call_immediately(STATE(handle_write));
        }
        else if ((((cmd & MemoryConfigDefs::COMMAND_MASK) ==
                      MemoryConfigDefs::COMMAND_READ_STREAM) ||
                     ((cmd & MemoryConfigDefs::COMMAND_MASK) ==
                         MemoryConfigDefs::COMMAND_WRITE_STREAM)) &&
            streamHandler_)
        {
            streamHandler_->send(transfer_message());
            return exit();
        }
        switch (cmd)
        {
            case MemoryConfigDefs::COMMAND_LOCK:
            {
                // Unknown/unsupported command, reject datagram.
                return respond_reject(Defs::ERROR_UNIMPLEMENTED_SUBCMD);
 
                // if (
                break;
            }
            case MemoryConfigDefs::COMMAND_FREEZE:
            {
                if (len < 3)
                {
                    return respond_reject(
                        Defs::ERROR_INVALID_ARGS_MESSAGE_TOO_SHORT);
                }
                uint8_t space = bytes[2];
                if (space != MemoryConfigDefs::SPACE_FIRMWARE)
                {
                    // Custom spaces cannot do free yet.
                    return respond_reject(Defs::ERROR_INVALID_ARGS);
                }
            }
            // Fall through
            case MemoryConfigDefs::COMMAND_ENTER_BOOTLOADER:
            {
                enter_bootloader();
                return respond_reject(Defs::ERROR_UNIMPLEMENTED_SUBCMD);
            }
            case MemoryConfigDefs::COMMAND_UPDATE_COMPLETE:
            {
                Singleton<ConfigUpdateService>::instance()->trigger_update();
                return respond_ok(0);
            }
            case MemoryConfigDefs::COMMAND_RESET:
            {
#if OPENMRN_FEATURE_REBOOT
                reboot();
#endif
                return respond_reject(Defs::ERROR_UNIMPLEMENTED_SUBCMD);
            }
            case MemoryConfigDefs::COMMAND_FACTORY_RESET:
            {
                NodeID id = message()->data()->dst->node_id();
                if (len < 8 || (data_to_node_id(&bytes[2]) != id))
                {
                    return respond_reject(Defs::ERROR_INVALID_ARGS);
                }
                uint16_t ret = handle_factory_reset(id);
                if (!ret)
                {
                    return respond_ok(0);
                }
                else
                {
                    return respond_reject(ret);
                }
            }
            case MemoryConfigDefs::COMMAND_OPTIONS:
            {
                return call_immediately(STATE(handle_options));
            }
            case MemoryConfigDefs::COMMAND_INFORMATION:
            {
                return call_immediately(STATE(handle_get_space_info));
            }
            case MemoryConfigDefs::COMMAND_WRITE_REPLY:
            case MemoryConfigDefs::COMMAND_WRITE_FAILED:
            case MemoryConfigDefs::COMMAND_WRITE_STREAM_REPLY:
            case MemoryConfigDefs::COMMAND_WRITE_STREAM_FAILED:
            case MemoryConfigDefs::COMMAND_READ_REPLY:
            case MemoryConfigDefs::COMMAND_READ_FAILED:
            case MemoryConfigDefs::COMMAND_READ_STREAM_REPLY:
            case MemoryConfigDefs::COMMAND_READ_STREAM_FAILED:
            case MemoryConfigDefs::COMMAND_OPTIONS_REPLY:
            case MemoryConfigDefs::COMMAND_INFORMATION_REPLY:
            case MemoryConfigDefs::COMMAND_LOCK_REPLY:
            case MemoryConfigDefs::COMMAND_UNIQUE_ID_REPLY:
            {
                if (client_)
                {
                    client_->send(transfer_message());
                    return exit();
                }
                LOG(VERBOSE, "memcfg handler reply: no client registered");
                // fall through to unsupported
            } // fall through
            default:
                // Unknown/unsupported command, reject datagram.
                return respond_reject(Defs::ERROR_UNIMPLEMENTED_SUBCMD);
        }
    }
 
    class RebootTimer : public ::Timer
    {
    public:
        RebootTimer(Service *s)
            : ::Timer(s->executor()->active_timers())
        { }
 
        long long timeout() override
        {
#if OPENMRN_FEATURE_REBOOT         
            reboot();
#endif            
            return DELETE;
        }
    };
 
    uint16_t handle_factory_reset(NodeID target);
 
    uint16_t __attribute__((noinline)) app_handle_factory_reset(NodeID target);
 
 
    Action handle_options()
    {
        response_.reserve(7);
        response_.push_back(DATAGRAM_ID);
        response_.push_back(MemoryConfigDefs::COMMAND_OPTIONS_REPLY);
        uint16_t available_commands =
            MemoryConfigDefs::AVAIL_UR | MemoryConfigDefs::AVAIL_UW;
        if (streamHandler_)
        {
            available_commands |= MemoryConfigDefs::AVAIL_SR;
        }
        // Figure out about ACDI spaces
        MemorySpace* memspace = registry_.lookup(message()->data()->dst, 0xFC);
        if (memspace) {
            available_commands |= MemoryConfigDefs::AVAIL_R0xFC;
        }
        memspace = registry_.lookup(message()->data()->dst, 0xFB);
        if (memspace) {
            available_commands |= MemoryConfigDefs::AVAIL_R0xFB;
            if (!memspace->read_only()) {
                available_commands |= MemoryConfigDefs::AVAIL_W0xFB;
            }
        }
        response_.push_back(available_commands >> 8);
        response_.push_back(available_commands & 0xff);
        // Write lengths
        response_.push_back(static_cast<char> (
            MemoryConfigDefs::LENGTH_1 | MemoryConfigDefs::LENGTH_2 |
            MemoryConfigDefs::LENGTH_4 | MemoryConfigDefs::LENGTH_ARBITRARY));
 
        uint8_t min_space = 0xFF;
        uint8_t max_space = 0;
        // Walks the spaces.
        for (auto it = registry_.begin(); it != registry_.end(); ++it) {
            auto h = *it;
            uint8_t space = h.first.second;
            Node* node = h.first.first;
            //MemorySpace* space_impl = h.second;
            if (node && node != message()->data()->dst) {
                continue;
            }
            if (space >= 0xFD) continue;
            if (space > max_space) max_space = space;
            if (space < min_space) min_space = space;
        }
        if (max_space < min_space) {
            max_space = 0xff;
            min_space = 0xfd;
        }
        response_.push_back(max_space);
        response_.push_back(min_space);
        return respond_ok(DatagramClient::REPLY_PENDING);
    }
 
    Action handle_get_space_info()
    {
        if (message()->data()->payload.size() < 3) {
            // Incoming message too short.
            return respond_reject(DatagramClient::PERMANENT_ERROR);
        }
        uint8_t space_number = in_bytes()[2];
        MemorySpace* space = registry_.lookup(message()->data()->dst, space_number);
        response_.reserve(8);
        response_.push_back(DATAGRAM_ID);
        response_.push_back(MemoryConfigDefs::COMMAND_INFORMATION_REPLY);
        response_.push_back(space_number);
        if (!space) {
            return respond_ok(DatagramDefs::REPLY_PENDING);
        } else {
            response_[1]++;
        }
        MemorySpace::address_t address = space->max_address();
        response_.push_back((address >> 24) & 0xff);
        response_.push_back((address >> 16) & 0xff);
        response_.push_back((address >> 8) & 0xff);
        response_.push_back(address & 0xff);
        uint8_t flags = 0;
        address = space->min_address();
        if (address) {
            flags |= MemoryConfigDefs::FLAG_NZLA;
        }
        if (space->read_only()) {
            flags |= MemoryConfigDefs::FLAG_RO;
        }
        response_.push_back(flags);
        if (address) {
            response_.push_back((address >> 24) & 0xff);
            response_.push_back((address >> 16) & 0xff);
            response_.push_back((address >> 8) & 0xff);
            response_.push_back(address & 0xff);
        }
        return respond_ok(DatagramDefs::REPLY_PENDING);
    }
 
    Action handle_read()
    {
        size_t len = message()->data()->payload.size();
        if (len <= 6)
        {
            return respond_reject(Defs::ERROR_INVALID_ARGS);
        }
        MemorySpace *space = get_space();
        if (!space)
        {
            return respond_reject(MemoryConfigDefs::ERROR_SPACE_NOT_KNOWN);
        }
        int read_len = get_read_length();
        if (read_len < 0)
        {
            return respond_reject(DatagramClient::PERMANENT_ERROR);
        }
        size_t response_data_offset = 6;
        if (has_custom_space())
        {
            ++response_data_offset;
        }
        size_t response_len = response_data_offset + read_len;
        currentOffset_ = 0;
        char c = 0;
        response_.assign(response_len, c);
        return call_immediately(STATE(try_read));
    }
 
    Action try_read() {
        MemorySpace *space = get_space();
        int read_len = get_read_length();
        address_t address = get_address();
        size_t response_data_offset = 6;
        if (has_custom_space())
        {
            ++response_data_offset;
        }
        address += currentOffset_;
        response_data_offset += currentOffset_;
        read_len -= currentOffset_;
        errorcode_t error = 0;
        uint8_t *response_bytes = out_bytes();
        if (read_len > 0)
        {
            int byte_read = space->read(address,
                response_bytes + response_data_offset, read_len, &error, this);
            currentOffset_ += byte_read;
            read_len -= byte_read;
            if (error == MemorySpace::ERROR_AGAIN)
            {
                return wait();
            }
            else if (error == 0 && read_len)
            {
                return again();
            }
        }
        if (error == MemoryConfigDefs::ERROR_OUT_OF_BOUNDS && currentOffset_)
        {
            // We can return a partial response.
            error = 0;
        }
        response_bytes[0] = DATAGRAM_ID;
        response_bytes[1] = error ? MemoryConfigDefs::COMMAND_READ_FAILED
                                  : MemoryConfigDefs::COMMAND_READ_REPLY;
        set_address_and_space();
        response_data_offset = 6;
        if (has_custom_space())
        {
            ++response_data_offset;
        }
        if (error)
        {
            response_.resize(response_data_offset + 2);
            out_bytes()[response_data_offset] = error >> 8;
            out_bytes()[response_data_offset + 1] = error & 0xff;
        }
        else
        {
            response_.resize(response_data_offset + currentOffset_);
        }
        return respond_ok(DatagramClient::REPLY_PENDING);
    }
 
    Action handle_write()
    {
        size_t len = message()->data()->payload.size();
        if (len <= 6)
        {
            return respond_reject(Defs::ERROR_INVALID_ARGS_MESSAGE_TOO_SHORT);
        }
        MemorySpace *space = get_space();
        if (!space)
        {
            return respond_reject(MemoryConfigDefs::ERROR_SPACE_NOT_KNOWN);
        }
        if (space->read_only())
        {
            return respond_reject(MemoryConfigDefs::ERROR_WRITE_TO_RO);
        }
        int write_len = get_write_length();
        if (write_len <= 0)
        {
            return respond_reject(Defs::ERROR_INVALID_ARGS);
        }
        currentOffset_ = 0;
        inline_respond_ok(DatagramClient::REPLY_PENDING);
        return call_immediately(STATE(try_write));
    }
 
    Action try_write()
    {
        MemorySpace *space = get_space();
        int write_len = get_write_length();
        address_t address = get_address();
        size_t data_offset = 6;
        if (has_custom_space())
        {
            ++data_offset;
        }
        address += currentOffset_;
        data_offset += currentOffset_;
        write_len -= currentOffset_;
        errorcode_t error = 0;
        if (write_len > 0)
        {
            size_t written = space->write(address, in_bytes() + data_offset,
                                          write_len, &error, this);
            currentOffset_ += written;
            write_len -= written;
            if (error == MemorySpace::ERROR_AGAIN)
            {
                return wait();
            }
            else if (error == 0 && write_len)
            {
                return again();
            }
        }
        char c = 0;
        int response_len = 6;
        if (has_custom_space())
        {
            response_len++;
        }
        if (error == 0)
        {
            response_.assign(response_len, c);
            out_bytes()[1] = MemoryConfigDefs::COMMAND_WRITE_REPLY;
        }
        else
        {
            response_.assign(response_len + 2, c);
            out_bytes()[1] = MemoryConfigDefs::COMMAND_WRITE_FAILED;
            out_bytes()[response_len] = error >> 8;
            out_bytes()[response_len + 1] = error & 0xff;
        }
        out_bytes()[0] = DATAGRAM_ID;
        set_address_and_space();
        return call_immediately(STATE(ok_response_sent));
    }
 
    MemorySpace *get_space()
    {
        int space_number = get_space_number();
        if (space_number < 0)
            return nullptr;
        MemorySpace *space =
            registry_.lookup(message()->data()->dst, space_number);
        if (!space)
        {
            LOG(WARNING, "MemoryConfig: asked node 0x%012" PRIx64 " for unknown space "
                         "%d. Source {0x%012" PRIx64 ", %03x}",
                message()->data()->dst->node_id(), space_number,
                message()->data()->src.id, message()->data()->src.alias);
            return nullptr;
        }
        if (!space->set_node(message()->data()->dst))
        {
            LOG(WARNING, "MemoryConfig: Global space %d rejected node.",
                space_number);
            return nullptr;
        }
        return space;
    }
 
    //NodeID lockNode_; //< Holds the node ID that locked us.
 
    Registry registry_;         //< holds the known memory spaces
    DatagramHandlerFlow* client_{nullptr};
    DatagramHandlerFlow *streamHandler_ {nullptr};
 
    uint8_t currentOffset_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_MEMORYCONFIG_HXX_