2017-12-03 20:01:41 +01:00
|
|
|
#include <cpp-utils/data/SerializationHelper.h>
|
2015-10-07 13:45:17 +02:00
|
|
|
#include "DirEntry.h"
|
2017-12-03 20:01:41 +01:00
|
|
|
#include <cstdint>
|
2015-10-07 13:45:17 +02:00
|
|
|
|
|
|
|
using std::vector;
|
2016-02-09 13:47:26 +01:00
|
|
|
using std::string;
|
2017-09-17 03:07:27 +02:00
|
|
|
using blockstore::BlockId;
|
2015-10-07 13:45:17 +02:00
|
|
|
|
|
|
|
namespace cryfs {
|
|
|
|
namespace fsblobstore {
|
2017-12-03 20:01:41 +01:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
template<typename DataType>
|
|
|
|
size_t _serialize(void* dst, const DataType& obj) {
|
|
|
|
cpputils::serialize<DataType>(dst, obj);
|
|
|
|
return sizeof(DataType);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename DataType>
|
|
|
|
DataType _deserialize(const char** src) {
|
|
|
|
DataType result = cpputils::deserialize<DataType>(*src);
|
|
|
|
*src += sizeof(DataType);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr size_t _serializedTimeValueSize() {
|
|
|
|
return sizeof(uint64_t) + sizeof(uint32_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int _serializeTimeValue(uint8_t *dest, timespec value) {
|
|
|
|
unsigned int offset = 0;
|
|
|
|
offset += _serialize<uint64_t>(dest + offset, value.tv_sec);
|
|
|
|
offset += _serialize<uint32_t>(dest + offset, value.tv_nsec);
|
|
|
|
ASSERT(offset == _serializedTimeValueSize(), "serialized to wrong size");
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
timespec _deserializeTimeValue(const char **pos) {
|
|
|
|
timespec value{};
|
|
|
|
value.tv_sec = _deserialize<uint64_t>(pos);
|
|
|
|
value.tv_nsec = _deserialize<uint32_t>(pos);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int _serializeString(uint8_t *dest, const string &value) {
|
|
|
|
std::memcpy(dest, value.c_str(), value.size()+1);
|
|
|
|
return value.size() + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
string _deserializeString(const char **pos) {
|
|
|
|
size_t length = strlen(*pos);
|
|
|
|
string value(*pos, length);
|
|
|
|
*pos += length + 1;
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int _serializeBlockId(uint8_t *dest, const BlockId &blockId) {
|
|
|
|
blockId.ToBinary(dest);
|
|
|
|
return blockId.BINARY_LENGTH;
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockId _deserializeBlockId(const char **pos) {
|
|
|
|
BlockId blockId = BlockId::FromBinary(*pos);
|
|
|
|
*pos += BlockId::BINARY_LENGTH;
|
|
|
|
return blockId;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-07 13:45:17 +02:00
|
|
|
void DirEntry::serialize(uint8_t *dest) const {
|
2016-02-09 13:05:16 +01:00
|
|
|
ASSERT(
|
2016-03-15 22:06:12 +01:00
|
|
|
((_type == fspp::Dir::EntryType::FILE) && S_ISREG(_mode) && !S_ISDIR(_mode) && !S_ISLNK(_mode)) ||
|
|
|
|
((_type == fspp::Dir::EntryType::DIR) && !S_ISREG(_mode) && S_ISDIR(_mode) && !S_ISLNK(_mode)) ||
|
|
|
|
((_type == fspp::Dir::EntryType::SYMLINK) && !S_ISREG(_mode) && !S_ISDIR(_mode) && S_ISLNK(_mode))
|
|
|
|
, "Wrong mode bit set for this type: " + std::to_string(_mode & S_IFREG) + ", " + std::to_string(
|
|
|
|
_mode & S_IFDIR) + ", " + std::to_string(_mode & S_IFLNK) + ", " + std::to_string(static_cast<uint8_t>(_type))
|
2016-02-09 13:05:16 +01:00
|
|
|
);
|
2015-10-07 13:45:17 +02:00
|
|
|
unsigned int offset = 0;
|
2017-12-03 20:01:41 +01:00
|
|
|
offset += _serialize<uint8_t>(dest + offset, static_cast<uint8_t>(_type));
|
|
|
|
offset += _serialize<uint32_t>(dest + offset, _mode);
|
|
|
|
offset += _serialize<uint32_t>(dest + offset, _uid);
|
|
|
|
offset += _serialize<uint32_t>(dest + offset, _gid);
|
2016-03-15 22:06:12 +01:00
|
|
|
offset += _serializeTimeValue(dest + offset, _lastAccessTime);
|
|
|
|
offset += _serializeTimeValue(dest + offset, _lastModificationTime);
|
|
|
|
offset += _serializeTimeValue(dest + offset, _lastMetadataChangeTime);
|
|
|
|
offset += _serializeString(dest + offset, _name);
|
2017-09-17 03:07:27 +02:00
|
|
|
offset += _serializeBlockId(dest + offset, _blockId);
|
2016-02-09 13:47:26 +01:00
|
|
|
ASSERT(offset == serializedSize(), "Didn't write correct number of elements");
|
|
|
|
}
|
2016-02-09 09:43:18 +01:00
|
|
|
|
2016-02-09 13:47:26 +01:00
|
|
|
const char *DirEntry::deserializeAndAddToVector(const char *pos, vector<DirEntry> *result) {
|
2017-12-03 20:01:41 +01:00
|
|
|
fspp::Dir::EntryType type = static_cast<fspp::Dir::EntryType>(_deserialize<uint8_t>(&pos));
|
|
|
|
mode_t mode = _deserialize<uint32_t>(&pos);
|
|
|
|
uid_t uid = _deserialize<uint32_t>(&pos);
|
|
|
|
gid_t gid = _deserialize<uint32_t>(&pos);
|
2016-02-09 13:47:26 +01:00
|
|
|
timespec lastAccessTime = _deserializeTimeValue(&pos);
|
|
|
|
timespec lastModificationTime = _deserializeTimeValue(&pos);
|
|
|
|
timespec lastMetadataChangeTime = _deserializeTimeValue(&pos);
|
|
|
|
string name = _deserializeString(&pos);
|
2017-09-17 03:07:27 +02:00
|
|
|
BlockId blockId = _deserializeBlockId(&pos);
|
2016-02-09 13:05:16 +01:00
|
|
|
|
2017-09-17 03:07:27 +02:00
|
|
|
result->emplace_back(type, name, blockId, mode, uid, gid, lastAccessTime, lastModificationTime, lastMetadataChangeTime);
|
2016-02-09 13:47:26 +01:00
|
|
|
return pos;
|
2015-10-07 13:45:17 +02:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:47:26 +01:00
|
|
|
size_t DirEntry::serializedSize() const {
|
2016-03-15 22:06:12 +01:00
|
|
|
return 1 + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + 3*_serializedTimeValueSize() + (
|
2017-09-17 03:07:27 +02:00
|
|
|
_name.size() + 1) + _blockId.BINARY_LENGTH;
|
2015-10-07 13:45:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|