LogonFeedback.hxx

Go to the documentation of this file.

 
#ifndef _DCC_LOGONFEEDBACK_HXX_
#define _DCC_LOGONFEEDBACK_HXX_
 
#include "dcc/RailcomHub.hxx"
#include "utils/Crc.hxx"
 
namespace dcc
{
 
class LogonFeedbackCallbacks
{
public:
    enum PacketType
    {
        UNKNOWN = 0,
        GET_DATA_START,
        GET_DATA_CONT,
        LOGON_ENABLE,
        SELECT_SHORTINFO,
        LOGON_ASSIGN,
        MISC_254
    };
 
    virtual PacketType classify_packet(uintptr_t feedback_key) = 0;
 
    virtual void process_select_shortinfo(
        uintptr_t feedback_key, bool error, uint64_t data) = 0;
 
    virtual void process_logon_assign(
        uintptr_t feedback_key, bool error, uint64_t data) = 0;
 
    virtual void process_decoder_id(
        uintptr_t feedback_key, bool error, uint64_t data) = 0;
};
 
class LogonFeedbackParser : public RailcomHubPortInterface
{
public:
    using PacketType = LogonFeedbackCallbacks::PacketType;
    LogonFeedbackParser(LogonFeedbackCallbacks *cb, RailcomHubFlow *hub)
        : cb_(cb)
        , hub_(hub)
    {
        hub_->register_port(this);
    }
 
    ~LogonFeedbackParser()
    {
        hub_->unregister_port(this);
    }
 
    void send(Buffer<RailcomHubData> *b, unsigned priority) override
    {
        auto rb = get_buffer_deleter(b);
        PacketType type = cb_->classify_packet(b->data()->feedbackKey);
        if (type == PacketType::UNKNOWN)
        {
            return;
        }
        uint64_t data = parse_code(b->data());
        bool any_error = data & ERROR_MASK;
        auto key = b->data()->feedbackKey;
        switch (type)
        {
            case PacketType::SELECT_SHORTINFO:
                any_error |= has_crc_error(data);
                any_error |= (((data >> 47) & 1) != 1);
                cb_->process_select_shortinfo(
                    key, any_error, data & PAYLOAD_MASK);
                break;
            case PacketType::LOGON_ASSIGN:
                any_error |= has_crc_error(data);
                any_error |=
                    (((data >> 44) & 0xf) != RMOB_LOGON_ASSIGN_FEEDBACK);
                cb_->process_logon_assign(key, any_error, data & PAYLOAD_MASK);
                break;
            case PacketType::LOGON_ENABLE:
                any_error |=
                    (((data >> 44) & 0xf) != RMOB_LOGON_ENABLE_FEEDBACK);
                cb_->process_decoder_id(key, any_error, data & PAYLOAD_MASK);
                break;
            case PacketType::GET_DATA_START:
            case PacketType::GET_DATA_CONT:
            case PacketType::MISC_254:
            case PacketType::UNKNOWN:
            default:
                break;
        }
    }
 
#ifndef GTEST
private:
#endif
    enum Errors
    {
        ERROR_SHIFT = 56,
        ERROR_MASK = 0xffULL << ERROR_SHIFT,
        LENGTH_SHIFT = 48,
        LENGTH_OFFSET = 1ULL << LENGTH_SHIFT,
        LENGTH_MASK = 0xffULL << LENGTH_SHIFT,
        PAYLOAD_MASK = LENGTH_OFFSET - 1,
 
        ERROR_MISSING_DATA = 1ULL << ERROR_SHIFT,
        ERROR_ACK = 2ULL << ERROR_SHIFT,
        ERROR_OUT_OF_ORDER = 4ULL << ERROR_SHIFT,
        ERROR_GARBAGE = 8ULL << ERROR_SHIFT,
        ERROR_UNKNOWN = 16ULL << ERROR_SHIFT,
    };
 
    static void append_data(uint64_t &data, unsigned &shift, uint8_t next_byte)
    {
        uint8_t code = railcom_decode[next_byte];
        if (code < 64)
        {
            data |= ((uint64_t)code) << shift;
            if (data >> ERROR_SHIFT)
            {
                // Valid data beyond some error.
                data |= ERROR_OUT_OF_ORDER;
            }
            data += LENGTH_OFFSET;
        }
        else if (code == RailcomDefs::ACK)
        {
            data |= ERROR_ACK;
        }
        else if (code == RailcomDefs::INV)
        {
            data |= ERROR_GARBAGE;
        }
        else
        {
            data |= ERROR_UNKNOWN;
        }
        shift -= 6;
    }
 
    static uint64_t parse_code(const Feedback *fb)
    {
        uint64_t data = 0;
        unsigned shift = 48 - 6;
        for (unsigned i = 0; i < 2; i++)
        {
            if (fb->ch1Size > i)
            {
                append_data(data, shift, fb->ch1Data[i]);
            }
            else
            {
                data |= ERROR_MISSING_DATA;
            }
        }
        for (unsigned i = 0; i < 6; i++)
        {
            if (fb->ch2Size > i)
            {
                append_data(data, shift, fb->ch2Data[i]);
            }
            else
            {
                data |= ERROR_MISSING_DATA;
            }
        }
        return data;
    }
 
    static bool has_crc_error(uint64_t data)
    {
        Crc8DallasMaxim m;
        for (int i = 48 - 8; i >= 0; i -= 8)
        {
            m.update16((data >> i) & 0xff);
        }
        return !m.check_ok();
    }
 
private:
    LogonFeedbackCallbacks *cb_;
    RailcomHubFlow *hub_;
};
 
} // namespace dcc
 
#endif // _DCC_LOGONFEEDBACK_HXX_