You've already forked crosspoint-reader
mirror of
https://github.com/crosspoint-reader/crosspoint-reader.git
synced 2026-02-13 15:13:44 -08:00
cb24947477
## Summary
* Definition and use of a central LOG function, that can later be
extended or completely be removed (for public use where debugging
information may not be required) to save flash by suppressing the
-DENABLE_SERIAL_LOG like in the slim branch
* **What changes are included?**
## Additional Context
* By using the central logger the usual:
```
#include <HardwareSerial.h>
...
Serial.printf("[%lu] [WCS] Obfuscating/deobfuscating %zu bytes\n", millis(), data.size());
```
would then become
```
#include <Logging.h>
...
LOG_DBG("WCS", "Obfuscating/deobfuscating %zu bytes", data.size());
```
You do have ``LOG_DBG`` for debug messages, ``LOG_ERR`` for error
messages and ``LOG_INF`` for informational messages. Depending on the
verbosity level defined (see below) soe of these message types will be
suppressed/not-compiled.
* The normal compilation (default) will create a firmware.elf file of
42.194.356 bytes, the same code via slim will create 42.024.048 bytes -
170.308 bytes less
* Firmware.bin : 6.469.984 bytes for default, 6.418.672 bytes for slim -
51.312 bytes less
### AI Usage
While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.
Did you use AI tools to help write this code? _NO_
---------
Co-authored-by: Xuan Son Nguyen <son@huggingface.co>
97 lines
2.3 KiB
C++
97 lines
2.3 KiB
C++
#include "KOReaderDocumentId.h"
|
|
|
|
#include <HalStorage.h>
|
|
#include <Logging.h>
|
|
#include <MD5Builder.h>
|
|
|
|
namespace {
|
|
// Extract filename from path (everything after last '/')
|
|
std::string getFilename(const std::string& path) {
|
|
const size_t pos = path.rfind('/');
|
|
if (pos == std::string::npos) {
|
|
return path;
|
|
}
|
|
return path.substr(pos + 1);
|
|
}
|
|
} // namespace
|
|
|
|
std::string KOReaderDocumentId::calculateFromFilename(const std::string& filePath) {
|
|
const std::string filename = getFilename(filePath);
|
|
if (filename.empty()) {
|
|
return "";
|
|
}
|
|
|
|
MD5Builder md5;
|
|
md5.begin();
|
|
md5.add(filename.c_str());
|
|
md5.calculate();
|
|
|
|
std::string result = md5.toString().c_str();
|
|
LOG_DBG("KODoc", "Filename hash: %s (from '%s')", result.c_str(), filename.c_str());
|
|
return result;
|
|
}
|
|
|
|
size_t KOReaderDocumentId::getOffset(int i) {
|
|
// Offset = 1024 << (2*i)
|
|
// For i = -1: KOReader uses a value of 0
|
|
// For i >= 0: 1024 << (2*i)
|
|
if (i < 0) {
|
|
return 0;
|
|
}
|
|
return CHUNK_SIZE << (2 * i);
|
|
}
|
|
|
|
std::string KOReaderDocumentId::calculate(const std::string& filePath) {
|
|
FsFile file;
|
|
if (!Storage.openFileForRead("KODoc", filePath, file)) {
|
|
LOG_DBG("KODoc", "Failed to open file: %s", filePath.c_str());
|
|
return "";
|
|
}
|
|
|
|
const size_t fileSize = file.fileSize();
|
|
LOG_DBG("KODoc", "Calculating hash for file: %s (size: %zu)", filePath.c_str(), fileSize);
|
|
|
|
// Initialize MD5 builder
|
|
MD5Builder md5;
|
|
md5.begin();
|
|
|
|
// Buffer for reading chunks
|
|
uint8_t buffer[CHUNK_SIZE];
|
|
size_t totalBytesRead = 0;
|
|
|
|
// Read from each offset (i = -1 to 10)
|
|
for (int i = -1; i < OFFSET_COUNT - 1; i++) {
|
|
const size_t offset = getOffset(i);
|
|
|
|
// Skip if offset is beyond file size
|
|
if (offset >= fileSize) {
|
|
continue;
|
|
}
|
|
|
|
// Seek to offset
|
|
if (!file.seekSet(offset)) {
|
|
LOG_DBG("KODoc", "Failed to seek to offset %zu", offset);
|
|
continue;
|
|
}
|
|
|
|
// Read up to CHUNK_SIZE bytes
|
|
const size_t bytesToRead = std::min(CHUNK_SIZE, fileSize - offset);
|
|
const size_t bytesRead = file.read(buffer, bytesToRead);
|
|
|
|
if (bytesRead > 0) {
|
|
md5.add(buffer, bytesRead);
|
|
totalBytesRead += bytesRead;
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
|
|
// Calculate final hash
|
|
md5.calculate();
|
|
std::string result = md5.toString().c_str();
|
|
|
|
LOG_DBG("KODoc", "Hash calculated: %s (from %zu bytes)", result.c_str(), totalBytesRead);
|
|
|
|
return result;
|
|
}
|