storage.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_SUPLET_STORAGE_H_
#define SRC_SUPLA_SUPLET_STORAGE_H_
 
#include <stdint.h>
#include <stddef.h>
#include <supla/suplet/channel_map.h>
#include <supla/suplet/config.h>
 
namespace Supla {
 
class Config;
 
namespace Suplet {
 
class ArtifactReader {
 public:
  virtual ~ArtifactReader() = default;
  virtual bool readArtifact(uint8_t instanceId,
                            uint32_t offset,
                            uint8_t *data,
                            uint16_t size) const = 0;
};
 
struct ArtifactStorageHandle {
  bool valid = false;
  uint8_t instanceId = 0;
  uint8_t variant = 0;
  uint16_t chunkIndex = 0;
  uint32_t artifactSize = 0;
  uint32_t receivedSize = 0;
  uint32_t crc32State = 0xFFFFFFFF;
};
 
struct InstanceRecord {
  InstanceRecord();
  InstanceRecord(const InstanceRecord &other);
  InstanceRecord &operator=(const InstanceRecord &other);
  ~InstanceRecord();
 
  bool setConfig(const uint8_t *data, uint16_t size);
  void clearConfig();
 
  uint8_t instanceId = 0;
  uint32_t definitionId = 0;
  uint16_t definitionVersion = 0;
  uint32_t revision = 0;
  uint8_t subDeviceId = 0;
  uint16_t configSize = 0;
  uint32_t artifactSize = 0;
  uint32_t artifactCrc32 = 0;
  ChannelMap channelMap = {};
  uint8_t *config = nullptr;
  const ArtifactReader *artifactReader = nullptr;
};
 
class InstanceTable {
 public:
  InstanceTable();
  InstanceTable(const InstanceTable &) = delete;
  InstanceTable &operator=(const InstanceTable &) = delete;
  ~InstanceTable();
 
  uint8_t getCount() const;
  void clear();
 
  bool add(const InstanceRecord &record);
  bool removeByInstanceId(uint8_t instanceId);
  InstanceRecord *findByInstanceId(uint8_t instanceId);
  const InstanceRecord *findByInstanceId(uint8_t instanceId) const;
  InstanceRecord *findBySubDeviceId(uint8_t subDeviceId);
  const InstanceRecord *findBySubDeviceId(uint8_t subDeviceId) const;
  InstanceRecord *getRecord(uint8_t index);
  const InstanceRecord *getRecord(uint8_t index) const;
 
 private:
  bool resize(uint8_t newCount);
 
  InstanceRecord *records = nullptr;
  uint8_t count = 0;
};
 
class Storage : public ArtifactReader {
 public:
  explicit Storage(Supla::Config *config);
 
  bool load(InstanceTable *table);
  bool loadIndex(InstanceTable *table);
  bool loadInstance(uint8_t instanceId, InstanceRecord *record);
  bool save(const InstanceTable &table,
            const ArtifactStorageHandle *stagedArtifact = nullptr);
  bool erase();
  bool beginStagedArtifact(uint8_t instanceId,
                           uint32_t artifactSize,
                           ArtifactStorageHandle *handle);
  bool writeStagedArtifactChunk(ArtifactStorageHandle *handle,
                                const uint8_t *data,
                                uint16_t size);
  bool abortStagedArtifact(ArtifactStorageHandle *handle);
  bool readArtifact(uint8_t instanceId,
                    uint32_t offset,
                    uint8_t *data,
                    uint16_t size) const override;
  static uint32_t stagedArtifactCrc32(
      const ArtifactStorageHandle &handle);
 
 private:
#pragma pack(push, 1)
  struct StoredInstanceHeader {
    uint8_t version = 0;
    uint8_t reserved = 0;
    uint32_t definitionId = 0;
    uint16_t definitionVersion = 0;
    uint8_t channelCount = 0;
    uint16_t configSize = 0;
    uint32_t revision = 0;
    uint32_t artifactSize = 0;
    uint32_t artifactCrc32 = 0;
  };
 
  struct StoredInstanceHeaderV3 {
    uint8_t version = 0;
    uint8_t reserved = 0;
    uint32_t definitionId = 0;
    uint16_t definitionVersion = 0;
    uint8_t channelCount = 0;
    uint16_t configSize = 0;
  };
 
  struct StoredChannelMapping {
    uint8_t channelId = 0;
    uint8_t channelNumber = 0;
  };
#pragma pack(pop)
 
  bool loadVariant(uint8_t instanceId, uint8_t variant, InstanceRecord *record)
      const;
  bool loadVariant(uint8_t instanceId,
                   uint8_t variant,
                   InstanceRecord *record,
                   bool loadConfig) const;
  bool loadVariantMetadata(uint8_t instanceId,
                           uint8_t variant,
                           InstanceRecord *record,
                           bool loadConfig) const;
  bool loadActiveVariant(uint8_t instanceId,
                         uint8_t *activeVariant,
                         InstanceRecord *record,
                         bool loadConfig,
                         bool cleanup);
  bool saveVariant(const InstanceRecord &record,
                   uint8_t variant,
                   const ArtifactStorageHandle *stagedArtifact);
  bool copyActiveArtifact(const InstanceRecord &record, uint8_t targetVariant);
  bool validateArtifact(uint8_t instanceId,
                        uint8_t variant,
                        uint32_t artifactSize,
                        uint32_t expectedCrc32) const;
  bool getActiveVariant(uint8_t instanceId, uint8_t *variant) const;
  bool readArtifactFromVariant(uint8_t instanceId,
                               uint8_t variant,
                               const InstanceRecord &record,
                               uint32_t offset,
                               uint8_t *data,
                               uint16_t size) const;
  bool eraseArtifactChunks(uint8_t instanceId, uint8_t variant);
  bool eraseVariant(uint8_t instanceId, uint8_t variant);
  bool eraseInstance(uint8_t instanceId);
  bool cleanupLoadedInstance(uint8_t instanceId,
                             uint8_t activeVariant,
                             uint8_t loadedVariant);
  bool slotExists(uint8_t instanceId) const;
  void makeActKey(uint8_t instanceId, char *output) const;
  void makeHeaderKey(uint8_t instanceId, uint8_t variant, char *output) const;
  void makeChannelMapKey(uint8_t instanceId,
                         uint8_t variant,
                         char *output) const;
  void makeConfigKey(uint8_t instanceId, uint8_t variant, char *output) const;
  void makeArtifactChunkKey(uint8_t instanceId,
                            uint8_t variant,
                            uint16_t chunkIndex,
                            char *output) const;
  bool readBlobExact(const char *key, char *output, size_t expectedSize) const;
 
  Supla::Config *config = nullptr;
};
 
}  // namespace Suplet
}  // namespace Supla
 
#endif  // SRC_SUPLA_SUPLET_STORAGE_H_