Attachment #704547 for bug #786459

View | Details | Raw Unified | Return to bug 786459
Collapse All | Expand All





  static DataNodeView create(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
    ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");
    cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
    ASSERT(serialized.size() == layout.blocksizeBytes(), "Wrong block size");
    auto block = blockStore->create(serialized);
    return DataNodeView(std::move(block));


  static DataNodeView initialize(cpputils::unique_ref<blockstore::Block> block, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
    ASSERT(data.size() <= DataNodeLayout(block->size()).datasizeBytes(), "Data is too large for node");
    cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
    ASSERT(serialized.size() == block->size(), "Block has wrong size");
    block->write(serialized.data(), 0, serialized.size());
    return DataNodeView(std::move(block));


  static DataNodeView overwrite(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, const blockstore::BlockId &blockId, cpputils::Data data) {
    ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");
    cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
    auto block = blockStore->overwrite(blockId, std::move(serialized));
    return DataNodeView(std::move(block));
  }

  }

private:
  static cpputils::Data (_serialize)(const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
    cpputils::Data result(layout.blocksizeBytes());
    cpputils::serialize<uint16_t>(result.dataOffset(layout.FORMAT_VERSION_OFFSET_BYTES), formatVersion);
    cpputils::serialize<uint8_t>(result.dataOffset(layout.DEPTH_OFFSET_BYTES), depth);





        namespace {
            template<typename DataType>
            size_t (_serialize)(void* dst, const DataType& obj) {
                cpputils::serialize<DataType>(dst, obj);
                return sizeof(DataType);
            }


            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;
            }

                    _mode.hasDirFlag()) + ", " + std::to_string(_mode.hasSymlinkFlag()) + ", " + std::to_string(static_cast<uint8_t>(_type))
            );
            unsigned int offset = 0;
            offset += (_serialize<uint8_t>)(dest + offset, static_cast<uint8_t>(_type));
            offset += (_serialize<uint32_t>)(dest + offset, _mode.value());
            offset += (_serialize<uint32_t>)(dest + offset, _uid.value());
            offset += (_serialize<uint32_t>)(dest + offset, _gid.value());
            offset += _serializeTimeValue(dest + offset, _lastAccessTime);
            offset += _serializeTimeValue(dest + offset, _lastModificationTime);
            offset += _serializeTimeValue(dest + offset, _lastMetadataChangeTime);

Lines 53-59 optional<LocalStateMetadata> LocalStateMetadata::_load(const bf::path &metadataF Link Here

(-)a/src/cryfs/localstate/LocalStateMetadata.cpp (-2 / +2 lines)
53		53
54	void LocalStateMetadata::_save(const bf::path &metadataFilePath) const {	54	void LocalStateMetadata::_save(const bf::path &metadataFilePath) const {
55	ofstream file(metadataFilePath.string(), std::ios::trunc);	55	ofstream file(metadataFilePath.string(), std::ios::trunc);
56	_serialize(file);	56	(_serialize)(file);
57	}	57	}
58		58
59	namespace {	59	namespace {
Lines 97-103 LocalStateMetadata LocalStateMetadata::_generate(const bf::path &metadataFilePat Link Here
97	return result;	97	return result;
98	}	98	}
99		99
100	void LocalStateMetadata::_serialize(ostream& stream) const {	100	void (LocalStateMetadata::_serialize)(ostream& stream) const {
101	ptree pt;	101	ptree pt;
102	pt.put<uint32_t>("myClientId", myClientId());	102	pt.put<uint32_t>("myClientId", myClientId());
103	pt.put<string>("encryptionKey.salt", _encryptionKeyHash.salt.ToString());	103	pt.put<string>("encryptionKey.salt", _encryptionKeyHash.salt.ToString());

Lines 24-30 private: Link Here

(-)a/src/cryfs/localstate/LocalStateMetadata.h (-1 / +1 lines)
24	static LocalStateMetadata _deserialize(std::istream& stream);	24	static LocalStateMetadata _deserialize(std::istream& stream);
25	static LocalStateMetadata _generate(const boost::filesystem::path &metadataFilePath, const cpputils::Data& encryptionKey);	25	static LocalStateMetadata _generate(const boost::filesystem::path &metadataFilePath, const cpputils::Data& encryptionKey);
26	void _save(const boost::filesystem::path &metadataFilePath) const;	26	void _save(const boost::filesystem::path &metadataFilePath) const;
27	void _serialize(std::ostream& stream) const;	27	void (_serialize)(std::ostream& stream) const;
28		28
29	LocalStateMetadata(uint32_t myClientId, cpputils::hash::Hash encryptionKey);	29	LocalStateMetadata(uint32_t myClientId, cpputils::hash::Hash encryptionKey);
30	};	30	};

Return to bug 786459

Lines 11-17 namespace cryfs { Link Here

(-)a/src/cryfs/filesystem/fsblobstore/utils/DirEntry.cpp (-7 / +7 lines)
11		11
12	namespace {	12	namespace {
13	template<typename DataType>	13	template<typename DataType>
14	size_t _serialize(void* dst, const DataType& obj) {	14	size_t (_serialize)(void* dst, const DataType& obj) {
15	cpputils::serialize<DataType>(dst, obj);	15	cpputils::serialize<DataType>(dst, obj);
16	return sizeof(DataType);	16	return sizeof(DataType);
17	}	17	}
Lines 29-36 namespace cryfs { Link Here
29		29
30	unsigned int _serializeTimeValue(uint8_t *dest, timespec value) {	30	unsigned int _serializeTimeValue(uint8_t *dest, timespec value) {
31	unsigned int offset = 0;	31	unsigned int offset = 0;
32	offset += _serialize<uint64_t>(dest + offset, value.tv_sec);	32	offset += (_serialize<uint64_t>)(dest + offset, value.tv_sec);
33	offset += _serialize<uint32_t>(dest + offset, value.tv_nsec);	33	offset += (_serialize<uint32_t>)(dest + offset, value.tv_nsec);
34	ASSERT(offset == _serializedTimeValueSize(), "serialized to wrong size");	34	ASSERT(offset == _serializedTimeValueSize(), "serialized to wrong size");
35	return offset;	35	return offset;
36	}	36	}
Lines 75-84 namespace cryfs { Link Here
75	_mode.hasDirFlag()) + ", " + std::to_string(_mode.hasSymlinkFlag()) + ", " + std::to_string(static_cast<uint8_t>(_type))	75	_mode.hasDirFlag()) + ", " + std::to_string(_mode.hasSymlinkFlag()) + ", " + std::to_string(static_cast<uint8_t>(_type))
76	);	76	);
77	unsigned int offset = 0;	77	unsigned int offset = 0;
78	offset += _serialize<uint8_t>(dest + offset, static_cast<uint8_t>(_type));	78	offset += (_serialize<uint8_t>)(dest + offset, static_cast<uint8_t>(_type));
79	offset += _serialize<uint32_t>(dest + offset, _mode.value());	79	offset += (_serialize<uint32_t>)(dest + offset, _mode.value());
80	offset += _serialize<uint32_t>(dest + offset, _uid.value());	80	offset += (_serialize<uint32_t>)(dest + offset, _uid.value());
81	offset += _serialize<uint32_t>(dest + offset, _gid.value());	81	offset += (_serialize<uint32_t>)(dest + offset, _gid.value());
82	offset += _serializeTimeValue(dest + offset, _lastAccessTime);	82	offset += _serializeTimeValue(dest + offset, _lastAccessTime);
83	offset += _serializeTimeValue(dest + offset, _lastModificationTime);	83	offset += _serializeTimeValue(dest + offset, _lastModificationTime);
84	offset += _serializeTimeValue(dest + offset, _lastMetadataChangeTime);	84	offset += _serializeTimeValue(dest + offset, _lastMetadataChangeTime);

Lines 67-73 public: Link Here

(-)a/src/blobstore/implementations/onblocks/datanodestore/DataNodeView.h (-4 / +4 lines)
67		67
68	static DataNodeView create(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {	68	static DataNodeView create(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
69	ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");	69	ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");
70	cpputils::Data serialized = _serialize(layout, formatVersion, depth, size, std::move(data));	70	cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
71	ASSERT(serialized.size() == layout.blocksizeBytes(), "Wrong block size");	71	ASSERT(serialized.size() == layout.blocksizeBytes(), "Wrong block size");
72	auto block = blockStore->create(serialized);	72	auto block = blockStore->create(serialized);
73	return DataNodeView(std::move(block));	73	return DataNodeView(std::move(block));
Lines 75-81 public: Link Here
75		75
76	static DataNodeView initialize(cpputils::unique_ref<blockstore::Block> block, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {	76	static DataNodeView initialize(cpputils::unique_ref<blockstore::Block> block, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
77	ASSERT(data.size() <= DataNodeLayout(block->size()).datasizeBytes(), "Data is too large for node");	77	ASSERT(data.size() <= DataNodeLayout(block->size()).datasizeBytes(), "Data is too large for node");
78	cpputils::Data serialized = _serialize(layout, formatVersion, depth, size, std::move(data));	78	cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
79	ASSERT(serialized.size() == block->size(), "Block has wrong size");	79	ASSERT(serialized.size() == block->size(), "Block has wrong size");
80	block->write(serialized.data(), 0, serialized.size());	80	block->write(serialized.data(), 0, serialized.size());
81	return DataNodeView(std::move(block));	81	return DataNodeView(std::move(block));
Lines 83-89 public: Link Here
83		83
84	static DataNodeView overwrite(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, const blockstore::BlockId &blockId, cpputils::Data data) {	84	static DataNodeView overwrite(blockstore::BlockStore *blockStore, const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, const blockstore::BlockId &blockId, cpputils::Data data) {
85	ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");	85	ASSERT(data.size() <= layout.datasizeBytes(), "Data is too large for node");
86	cpputils::Data serialized = _serialize(layout, formatVersion, depth, size, std::move(data));	86	cpputils::Data serialized = (_serialize)(layout, formatVersion, depth, size, std::move(data));
87	auto block = blockStore->overwrite(blockId, std::move(serialized));	87	auto block = blockStore->overwrite(blockId, std::move(serialized));
88	return DataNodeView(std::move(block));	88	return DataNodeView(std::move(block));
89	}	89	}
Lines 143-149 public: Link Here
143	}	143	}
144		144
145	private:	145	private:
146	static cpputils::Data _serialize(const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {	146	static cpputils::Data (_serialize)(const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) {
147	cpputils::Data result(layout.blocksizeBytes());	147	cpputils::Data result(layout.blocksizeBytes());
148	cpputils::serialize<uint16_t>(result.dataOffset(layout.FORMAT_VERSION_OFFSET_BYTES), formatVersion);	148	cpputils::serialize<uint16_t>(result.dataOffset(layout.FORMAT_VERSION_OFFSET_BYTES), formatVersion);
149	cpputils::serialize<uint8_t>(result.dataOffset(layout.DEPTH_OFFSET_BYTES), depth);	149	cpputils::serialize<uint8_t>(result.dataOffset(layout.DEPTH_OFFSET_BYTES), depth);