mifareaccessinfo.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_MIFAREACCESSINFO_HPP
#define LOGICALACCESS_MIFAREACCESSINFO_HPP
 
#include <logicalaccess/cards/accessinfo.hpp>
#include <logicalaccess/plugins/cards/mifare/mifarekey.hpp>
 
namespace logicalaccess
{
typedef enum { KT_KEY_A = 0x60, KT_KEY_B = 0x61 } MifareKeyType;
 
LLA_CARDS_MIFARE_API std::ostream &operator<<(std::ostream &s, const MifareKeyType &k);
 
class LLA_CARDS_MIFARE_API MifareAccessInfo : public AccessInfo
{
  public:
    using XmlSerializable::serialize;
    using XmlSerializable::unSerialize;
 
    MifareAccessInfo();
 
    virtual ~MifareAccessInfo();
 
    void generateInfos() override;
 
    std::string getCardType() const override;
 
    void serialize(boost::property_tree::ptree &parentNode) override;
 
    void unSerialize(boost::property_tree::ptree &parentNode) override;
 
    std::string getDefaultXmlNodeName() const override;
 
    bool operator==(const AccessInfo &ai) const override;
 
    struct LLA_CARDS_MIFARE_API BlockAccessBits
    {
        BlockAccessBits(bool v1, bool v2, bool v3)
            : c1(v1)
            , c2(v2)
            , c3(v3)
        {
        }
 
        bool operator==(const BlockAccessBits &bab) const
        {
            return ((c1 == bab.c1) && (c2 == bab.c2) && (c3 == bab.c3));
        }
 
        bool c1; 
        bool c2; 
        bool c3; 
    };
 
    struct LLA_CARDS_MIFARE_API DataBlockAccessBits : BlockAccessBits
    {
        DataBlockAccessBits()
            : BlockAccessBits(false, false, false)
        {
        }
 
        static void *getItem(void *arrayPtr, int i)
        {
            return &static_cast<DataBlockAccessBits *>(arrayPtr)[i];
        }
 
        static void setItem(void *arrayPtr, const DataBlockAccessBits *item, int i)
        {
            if (item)
                static_cast<DataBlockAccessBits *>(arrayPtr)[i] = *item;
            else
                static_cast<DataBlockAccessBits *>(arrayPtr)[i] = DataBlockAccessBits();
        }
    };
 
    struct LLA_CARDS_MIFARE_API SectorTrailerAccessBits : BlockAccessBits
    {
        SectorTrailerAccessBits()
            : BlockAccessBits(false, false, true)
        {
        }
 
        static void *getItem(void *arrayPtr, int i)
        {
            return &static_cast<SectorTrailerAccessBits *>(arrayPtr)[i];
        }
 
        static void setItem(void *arrayPtr, const SectorTrailerAccessBits *item, int i)
        {
            if (item)
                static_cast<SectorTrailerAccessBits *>(arrayPtr)[i] = *item;
            else
                static_cast<SectorTrailerAccessBits *>(arrayPtr)[i] =
                    SectorTrailerAccessBits();
        }
    };
 
    struct LLA_CARDS_MIFARE_API SectorAccessBits
    {
        ByteVector toArray() const;
 
        bool fromArray(ByteVector);
 
        void setTransportConfiguration();
 
        void setAReadBWriteConfiguration();
        void setAReadNeverWriteConfiguration();
        void setBReadBWriteConfiguration();
        void setBReadNeverWriteConfiguration();
        void setNeverReadNeverWriteConfiguration();
        void setNfcConfiguration();
 
        bool operator==(SectorAccessBits a)
        {
          if (a.d_sector_trailer_access_bits.c1 != this->d_sector_trailer_access_bits.c1
            || a.d_sector_trailer_access_bits.c2 != this->d_sector_trailer_access_bits.c2
            || a.d_sector_trailer_access_bits.c3 != this->d_sector_trailer_access_bits.c3)
            return false;
          for (unsigned int i = 0; i < 3; ++i)
          {
            if (a.d_data_blocks_access_bits[i].c1 != this->d_data_blocks_access_bits[i].c1
              || a.d_data_blocks_access_bits[i].c2 != this->d_data_blocks_access_bits[i].c2
              || a.d_data_blocks_access_bits[i].c3 != this->d_data_blocks_access_bits[i].c3)
              return false;
          }
          return true;
        }
 
        bool operator!=(const SectorAccessBits a)
        {
          bool b = (*this) == a;
          return !b;
        }
 
        DataBlockAccessBits
            d_data_blocks_access_bits[3]; 
        SectorTrailerAccessBits
            d_sector_trailer_access_bits; 
    };
 
 
    std::shared_ptr<MifareKey> keyA;
 
    std::shared_ptr<MifareKey> keyB;
 
    bool useMAD;
 
    std::shared_ptr<MifareKey> madKeyA;
 
    std::shared_ptr<MifareKey> madKeyB;
 
    SectorAccessBits sab;
 
    unsigned char gpb;
 
    unsigned char madGPB;
};
}
 
#endif /* LOGICALACCESS_MIFAREACCESSINFO_HPP */