HdlcdPacketCtrl.h

Go to the documentation of this file.

#ifndef HDLCD_PACKET_CTRL_H
#define HDLCD_PACKET_CTRL_H

#include "HdlcdPacket.h"
#include <memory>

class HdlcdPacketCtrl: public HdlcdPacket {
public:
    // Types of control packets
    typedef enum {
        CTRL_TYPE_PORT_STATUS = 0x00,
        CTRL_TYPE_ECHO        = 0x10,
        CTRL_TYPE_KEEP_ALIVE  = 0x20,
        CTRL_TYPE_PORT_KILL   = 0x30,
        CTRL_TYPE_UNSET       = 0xFF
    } E_CTRL_TYPE;

    static std::shared_ptr<HdlcdPacketCtrl> CreateDeserializedPacket() {
        // Called on reception: evaluate type field
        auto l_PacketCtrl(std::shared_ptr<HdlcdPacketCtrl>(new HdlcdPacketCtrl));
        l_PacketCtrl->m_eDeserialize   = DESERIALIZE_BODY; // Next: read body including the packet type byte
        l_PacketCtrl->m_BytesRemaining = 2;
        return l_PacketCtrl;
    }
    
    //
    static HdlcdPacketCtrl CreatePortStatusRequest(bool a_bLockSerialPort) {
        HdlcdPacketCtrl l_PacketCtrl;
        l_PacketCtrl.m_eCtrlType = CTRL_TYPE_PORT_STATUS;
        l_PacketCtrl.m_bLockSerialPort = a_bLockSerialPort;
        return l_PacketCtrl;
    }
    
    static HdlcdPacketCtrl CreatePortStatusResponse(bool a_bIsAlive, bool a_bIsLockedByOthers, bool a_bIsLockedBySelf) {
        HdlcdPacketCtrl l_PacketCtrl;
        l_PacketCtrl.m_eCtrlType = CTRL_TYPE_PORT_STATUS;
        l_PacketCtrl.m_bAlive = a_bIsAlive;
        l_PacketCtrl.m_bLockedByOthers = a_bIsLockedByOthers;
        l_PacketCtrl.m_bLockedBySelf = a_bIsLockedBySelf;
        return l_PacketCtrl;
    }
    
    static HdlcdPacketCtrl CreateEchoRequest() {
        HdlcdPacketCtrl l_PacketCtrl;
        l_PacketCtrl.m_eCtrlType = CTRL_TYPE_ECHO;
        return l_PacketCtrl;
    }
    
    static HdlcdPacketCtrl CreateKeepAliveRequest() {
        HdlcdPacketCtrl l_PacketCtrl;
        l_PacketCtrl.m_eCtrlType = CTRL_TYPE_KEEP_ALIVE;
        return l_PacketCtrl;
    }
    
    static HdlcdPacketCtrl CreatePortKillRequest() {
        HdlcdPacketCtrl l_PacketCtrl;
        l_PacketCtrl.m_eCtrlType = CTRL_TYPE_PORT_KILL;        
        return l_PacketCtrl;
    }
    
    // Getters
    E_CTRL_TYPE GetPacketType() const {
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_eCtrlType;
    }

    bool GetIsAlive() const {
        assert(m_eCtrlType == CTRL_TYPE_PORT_STATUS);
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_bAlive;
    }

    bool GetIsLockedByOthers() const {
        assert(m_eCtrlType == CTRL_TYPE_PORT_STATUS);
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_bLockedByOthers;
    }

    bool GetIsLockedBySelf() const {
        assert(m_eCtrlType == CTRL_TYPE_PORT_STATUS);
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_bLockedBySelf;
    }

    bool GetDesiredLockState() const {
        assert(m_eCtrlType == CTRL_TYPE_PORT_STATUS);
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_bLockSerialPort;
    }

private:
    // Private CTOR
    HdlcdPacketCtrl(): m_bAlive(false), m_bLockedByOthers(false), m_bLockedBySelf(false), m_bLockSerialPort(false),
                       m_eCtrlType(CTRL_TYPE_UNSET), m_eDeserialize(DESERIALIZE_FULL) {
    }
    
    // Internal helpers
    E_HDLCD_PACKET GetHdlcdPacketType() const { return HDLCD_PACKET_CTRL; }

    // Serializer
    const std::vector<unsigned char> Serialize() const {
        assert(m_eDeserialize == DESERIALIZE_FULL);
        std::vector<unsigned char> l_Buffer;
        l_Buffer.emplace_back(0x10);
        
        // Prepare control field
        unsigned char l_Control = 0x00;
        switch (m_eCtrlType) {
            case CTRL_TYPE_PORT_STATUS:
                l_Control = 0x00;
                if (m_bAlive)          { l_Control |= 0x04; }
                if (m_bLockedByOthers) { l_Control |= 0x02; }
                if (m_bLockedBySelf)   { l_Control |= 0x01; }
                if (m_bLockSerialPort) { l_Control |= 0x01; } // for requests
                break;
            case CTRL_TYPE_ECHO:
                l_Control = 0x10;
                break;
            case CTRL_TYPE_KEEP_ALIVE:
                l_Control = 0x20;
                break;
            case CTRL_TYPE_PORT_KILL:
                l_Control = 0x30;
                break;
            default:
                assert(false);
        } // switch

        l_Buffer.emplace_back(l_Control);
        return l_Buffer;
    }
    
    // Deserializer
    bool Deserialize() {
        // All requested bytes are available
        switch (m_eDeserialize) {
        case DESERIALIZE_BODY: {
            // Deserialize the control byte
            assert(m_Buffer.size() == 2);
            if (m_Buffer[0] != HDLCD_PACKET_CTRL) {
                // Wrong control field
                m_eDeserialize = DESERIALIZE_ERROR;
                return false;
            } // if

            const unsigned char &l_Control = m_Buffer[1];
            m_Buffer.clear();
            switch (l_Control & 0xF0) {
            case 0x00: {
                m_eCtrlType = CTRL_TYPE_PORT_STATUS;
                // For both requests and responses
                if (l_Control & 0x08) {
                    // The reserved bit was set... abort
                    m_eDeserialize = DESERIALIZE_ERROR;
                    return false;
                } // if

                m_bAlive          = (l_Control & 0x04);
                m_bLockedByOthers = (l_Control & 0x02);
                m_bLockedBySelf   = (l_Control & 0x01);
                m_bLockSerialPort = (l_Control & 0x01); // for requests
                break;
            }
            case 0x10: {
                m_eCtrlType = CTRL_TYPE_ECHO;
                break;
            }
            case 0x20: {
                m_eCtrlType = CTRL_TYPE_KEEP_ALIVE;
                break;
            }
            case 0x30: {
                m_eCtrlType = CTRL_TYPE_PORT_KILL;
                break;
            }
            default:
                m_eDeserialize = DESERIALIZE_ERROR;
                return false;
            } // switch

            // Read of control packet completed
            m_eDeserialize = DESERIALIZE_FULL;
            break;
        }
        case DESERIALIZE_ERROR:
        case DESERIALIZE_FULL:
        default:
            assert(false);
        } // switch

        // No error
        return true;
    }

    // Members
    bool m_bAlive;
    bool m_bLockedByOthers;
    bool m_bLockedBySelf;
    bool m_bLockSerialPort;
    
    E_CTRL_TYPE m_eCtrlType;
    typedef enum {
        DESERIALIZE_ERROR = 0,
        DESERIALIZE_BODY  = 1,
        DESERIALIZE_FULL  = 2
    } E_DESERIALIZE;
    E_DESERIALIZE m_eDeserialize;
};

#endif // HDLCD_PACKET_CTRL_H