Datagram.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_DATAGRAM_HXX_
#define _OPENLCB_DATAGRAM_HXX_
 
#include "utils/NodeHandlerMap.hxx"
#include "utils/Queue.hxx"
#include "openlcb/If.hxx"
 
namespace openlcb
{
 
struct IncomingDatagram;
 
extern long long DATAGRAM_RESPONSE_TIMEOUT_NSEC;
 
typedef Payload DatagramPayload;
 
struct IncomingDatagram
{
    NodeHandle src;
    Node *dst;
    DatagramPayload payload;
};
 
extern Pool *const g_incoming_datagram_allocator;
 
typedef FlowInterface<Buffer<IncomingDatagram>> DatagramHandler;
typedef StateFlow<Buffer<IncomingDatagram>, QList<1>> DatagramHandlerFlow;
 
class DatagramClient : public QMember
{
public:
    virtual ~DatagramClient()
    {
    }
 
    virtual void write_datagram(Buffer<GenMessage> *b,
                                unsigned priority = UINT_MAX) = 0;
 
    virtual void cancel() = 0;
 
    uint32_t result()
    {
        return result_;
    }
 
    enum ResultCodes
    {
        PERMANENT_ERROR = 0x1000,
        RESEND_OK = 0x2000,
        // Resend OK errors
        TRANSPORT_ERROR = 0x4000,
        BUFFER_UNAVAILABLE = 0x0020,
        OUT_OF_ORDER = 0x0040,
        // Permanent error error bits
        SOURCE_NOT_PERMITTED = 0x0020,
        DATAGRAMS_NOT_ACCEPTED = 0x0040,
 
        // Internal error codes generated by the send flow
        OPERATION_SUCCESS = 0x10000, //< set when the Datagram OK arrives
        OPERATION_PENDING = 0x20000, //< cleared when done is called.
        DST_NOT_FOUND = Defs::ERROR_DST_NOT_FOUND, //< on CAN. Permanent error code.
        TIMEOUT = Defs::OPENMRN_TIMEOUT,       //< Timeout waiting for ack/nack.
        DST_REBOOT = Defs::ERROR_DST_REBOOT, //< Target node has rebooted.
 
        // The top byte of result_ is the response flags from Datagram_OK
        // response.
        RESPONSE_FLAGS_SHIFT = 24,
        RESPONSE_CODE_MASK = (1<<RESPONSE_FLAGS_SHIFT) - 1,
        OK_REPLY_PENDING = (1 << 31),
    };
 
    // These values are okay in the respond_ok flags byte.
    enum ResponseFlag
    {
        REPLY_PENDING = 0x80,
        REPLY_TIMEOUT_SEC = 0x1,
        REPLY_TIMEOUT_MASK = 0xf,
    };
 
protected:
    uint32_t result_;
};
 
class DatagramService : public Service
{
public:
    typedef TypedNodeHandlerMap<Node, DatagramHandler> Registry;
 
    DatagramService(If *iface, size_t num_registry_entries);
    ~DatagramService();
 
    Registry *registry()
    {
        return dispatcher_.registry();
    }
 
    TypedQAsync<DatagramClient> *client_allocator()
    {
        return &clients_;
    }
 
    If *iface()
    {
        return iface_;
    }
 
private:
    class DatagramDispatcher : public IncomingMessageStateFlow
    {
    public:
        DatagramDispatcher(If *iface, size_t num_registry_entries)
            : IncomingMessageStateFlow(iface)
            , registry_(num_registry_entries)
        {
        }
 
        ~DatagramDispatcher()
        {
        }
 
        Registry *registry()
        {
            return &registry_;
        }
 
    private:
        Action entry() override;
 
        Action incoming_datagram_allocated();
        Action respond_rejection();
 
        Buffer<IncomingDatagram> *d_; //< Datagram to send to handler.
        uint16_t resultCode_;         //< Rejection reason
 
        Registry registry_;
 
        // TypedAllocator<IncomingMessageHandler> lock_;
    };
 
    If *iface_;
 
    TypedQAsync<DatagramClient> clients_;
 
    DatagramDispatcher dispatcher_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_DATAGRAM_HXX_