supla-device
Loading...
Searching...
No Matches
definition_cache.h
1/*
2 Copyright (C) AC SOFTWARE SP. Z O.O
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19#ifndef SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_
20#define SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_
21
22#include <stddef.h>
23#include <stdint.h>
24#include <supla/suplet/config.h>
25
26namespace Supla {
27
28class Config;
29
30namespace Suplet {
31
32class Sha256Provider {
33 public:
34 virtual ~Sha256Provider() {
35 }
36 virtual bool calculate(const uint8_t *data,
37 size_t dataSize,
38 uint8_t *output,
39 size_t outputSize) = 0;
40};
41
42#if !defined(SUPLA_TEST) && (defined(ESP32) || defined(SUPLA_DEVICE_ESP32))
43class DefaultSha256Provider : public Sha256Provider {
44 public:
45 bool calculate(const uint8_t *data,
46 size_t dataSize,
47 uint8_t *output,
48 size_t outputSize) override;
49};
50#endif
51
52struct CachedDefinitionInfo {
53 uint32_t definitionId = 0;
54 uint16_t definitionVersion = 0;
55 uint16_t jsonSize = 0;
56 uint8_t sha256[32] = {};
57};
58
59struct DefinitionCacheHandle {
60 uint8_t slot = 255;
61 uint8_t variant = 0;
62};
63
64class DefinitionCache {
65 public:
66 DefinitionCache(Supla::Config *config, Sha256Provider *sha256Provider);
67
68 bool save(uint32_t definitionId,
69 uint16_t definitionVersion,
70 const char *json,
71 const uint8_t *expectedSha256);
72 bool load(uint32_t definitionId,
73 uint16_t definitionVersion,
74 char *json,
75 size_t jsonSize,
76 CachedDefinitionInfo *info = nullptr) const;
77 bool contains(uint32_t definitionId, uint16_t definitionVersion) const;
78 bool erase(uint32_t definitionId, uint16_t definitionVersion);
79 bool getInfo(uint8_t index, CachedDefinitionInfo *info) const;
80 bool getInfoAndRepair(uint8_t index, CachedDefinitionInfo *info) const;
81 bool beginStagedSave(uint32_t definitionId,
82 uint16_t definitionVersion,
83 uint16_t jsonSize,
84 const uint8_t *sha256,
85 DefinitionCacheHandle *handle);
86 bool writeStagedChunk(DefinitionCacheHandle handle,
87 uint16_t chunkIndex,
88 const uint8_t *data,
89 uint16_t size);
90 bool loadStaged(DefinitionCacheHandle handle,
91 uint32_t definitionId,
92 uint16_t definitionVersion,
93 char *json,
94 size_t jsonSize,
95 CachedDefinitionInfo *info = nullptr) const;
96 bool commitStaged(DefinitionCacheHandle handle,
97 uint32_t definitionId,
98 uint16_t definitionVersion,
99 uint16_t jsonSize,
100 const uint8_t *sha256);
101 bool abortStaged(DefinitionCacheHandle handle);
102
103 private:
104 bool calculateAndVerify(const char *json,
105 uint16_t jsonSize,
106 const uint8_t *expectedSha256,
107 uint8_t *calculatedSha256) const;
108 bool readActiveHeader(uint8_t index,
109 CachedDefinitionInfo *info,
110 uint8_t *activeVariant = nullptr,
111 uint16_t *chunkCount = nullptr,
112 uint16_t *chunkSize = nullptr) const;
113 bool loadAndRepairActiveHeader(uint8_t index,
114 CachedDefinitionInfo *info,
115 uint8_t *activeVariant = nullptr,
116 uint16_t *chunkCount = nullptr,
117 uint16_t *chunkSize = nullptr) const;
118 bool loadHeader(uint8_t index,
119 uint8_t variant,
120 CachedDefinitionInfo *info,
121 uint16_t *chunkCount = nullptr,
122 uint16_t *chunkSize = nullptr) const;
123 bool saveSlot(uint8_t index,
124 uint32_t definitionId,
125 uint16_t definitionVersion,
126 const char *json,
127 uint16_t jsonSize,
128 const uint8_t *sha256);
129 bool saveHeader(uint8_t index,
130 uint8_t variant,
131 const CachedDefinitionInfo &info,
132 uint16_t chunkCount,
133 uint16_t chunkSize);
134 bool loadPayload(uint8_t slot,
135 uint8_t variant,
136 const CachedDefinitionInfo &info,
137 uint16_t chunkCount,
138 uint16_t chunkSize,
139 char *json,
140 size_t jsonSize) const;
141 bool eraseChunks(uint8_t index, uint8_t variant);
142 bool eraseVariant(uint8_t index, uint8_t variant);
143 bool eraseLegacySlot(uint8_t index);
144 bool eraseSlot(uint8_t index);
145 bool setActiveVariant(uint8_t index, uint8_t variant);
146 bool variantExists(uint8_t index, uint8_t variant) const;
147 bool slotExists(uint8_t index) const;
148 int findSlot(uint32_t definitionId,
149 uint16_t definitionVersion,
150 bool repair) const;
151 int findFreeSlot() const;
152 static uint8_t otherVariant(uint8_t variant);
153 static bool isValidVariant(uint8_t variant);
154 static bool isValidHandle(DefinitionCacheHandle handle);
155 static bool makeActKey(uint8_t index, char *output, size_t outputSize);
156 static bool makeHeaderKey(uint8_t index,
157 uint8_t variant,
158 char *output,
159 size_t outputSize);
160 static bool makeChunkKey(uint8_t index,
161 uint8_t variant,
162 uint16_t chunkIndex,
163 char *output,
164 size_t outputSize);
165 static bool makeLegacyHeaderKey(uint8_t index,
166 char *output,
167 size_t outputSize);
168 static bool makeLegacyChunkKey(uint8_t index,
169 uint16_t chunkIndex,
170 char *output,
171 size_t outputSize);
172
173 Supla::Config *config = nullptr;
174 Sha256Provider *sha256Provider = nullptr;
175};
176
177} // namespace Suplet
178} // namespace Supla
179
180#endif // SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_
Supla::Config
Definition config.h:59
Supla::Suplet::Sha256Provider
Definition definition_cache.h:32
Supla::Suplet::CachedDefinitionInfo
Definition definition_cache.h:52
Supla::Suplet::DefinitionCacheHandle
Definition definition_cache.h:59
Generated by doxygen 1.17.0