commit: 3d938ca65dc367476475ef148fd20cb2cf1472f7 Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Mon May 10 10:46:20 2021 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Mon May 10 10:46:48 2021 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=3d938ca6
sys-fs/cryfs: add GCC 11 patch (And fix the paths from PR which I hadn't staged...) Closes: https://bugs.gentoo.org/786459 Signed-off-by: Sam James <sam <AT> gentoo.org> sys-fs/cryfs/cryfs-0.10.3.ebuild | 7 +- sys-fs/cryfs/files/cryfs-0.10.3-gcc11.patch | 271 ++++++++++++++++++++++++++++ 2 files changed, 276 insertions(+), 2 deletions(-) diff --git a/sys-fs/cryfs/cryfs-0.10.3.ebuild b/sys-fs/cryfs/cryfs-0.10.3.ebuild index 16a91505cca..05cf0d45dc4 100644 --- a/sys-fs/cryfs/cryfs-0.10.3.ebuild +++ b/sys-fs/cryfs/cryfs-0.10.3.ebuild @@ -37,8 +37,10 @@ DEPEND="${RDEPEND} PATCHES=( # TODO upstream: - "${FILESDIR}/0.10.2-unbundle-libs.patch" - "${FILESDIR}/0.10.2-install-targets.patch" + "${FILESDIR}/${PN}-0.10.2-unbundle-libs.patch" + "${FILESDIR}/${PN}-0.10.2-install-targets.patch" + # From upstream + "${FILESDIR}/${PN}-0.10.3-gcc11.patch" ) pkg_setup() { @@ -71,6 +73,7 @@ src_configure() { -DUSE_SYSTEM_LIBS=ON -DBUILD_TESTING=$(usex test) ) + use custom-optimization || append-flags -O3 use debug || append-flags -DNDEBUG diff --git a/sys-fs/cryfs/files/cryfs-0.10.3-gcc11.patch b/sys-fs/cryfs/files/cryfs-0.10.3-gcc11.patch new file mode 100644 index 00000000000..9a7252ba506 --- /dev/null +++ b/sys-fs/cryfs/files/cryfs-0.10.3-gcc11.patch @@ -0,0 +1,271 @@ +https://github.com/cryfs/cryfs/commit/27587ea1acec5f939a31217f1c43953378f18821.patch +https://bugs.gentoo.org/786459 + +From 27587ea1acec5f939a31217f1c43953378f18821 Mon Sep 17 00:00:00 2001 +From: Sebastian Messmer <mess...@cryfs.org> +Date: Sat, 8 May 2021 14:44:27 -0700 +Subject: [PATCH] Fixed an issue when compiling with GCC 11, see + https://github.com/cryfs/cryfs/issues/389 + +--- +--- a/src/blobstore/implementations/onblocks/datanodestore/DataNodeView.h ++++ b/src/blobstore/implementations/onblocks/datanodestore/DataNodeView.h +@@ -67,7 +67,7 @@ class DataNodeView final { + + 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)); ++ 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)); +@@ -75,7 +75,7 @@ class DataNodeView final { + + 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)); ++ 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)); +@@ -83,7 +83,7 @@ class DataNodeView final { + + 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)); ++ cpputils::Data serialized = serialize_(layout, formatVersion, depth, size, std::move(data)); + auto block = blockStore->overwrite(blockId, std::move(serialized)); + return DataNodeView(std::move(block)); + } +@@ -143,7 +143,7 @@ class DataNodeView final { + } + + private: +- static cpputils::Data _serialize(const DataNodeLayout &layout, uint16_t formatVersion, uint8_t depth, uint32_t size, cpputils::Data data) { ++ 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); +--- a/src/cryfs/filesystem/fsblobstore/utils/DirEntry.cpp ++++ b/src/cryfs/filesystem/fsblobstore/utils/DirEntry.cpp +@@ -11,55 +11,55 @@ namespace cryfs { + + namespace { + template<typename DataType> +- size_t _serialize(void* dst, const DataType& obj) { ++ 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 deserialize_(const char** src) { + DataType result = cpputils::deserialize<DataType>(*src); + *src += sizeof(DataType); + return result; + } + +- constexpr size_t _serializedTimeValueSize() { ++ constexpr size_t serializedTimeValueSize_() { + return sizeof(uint64_t) + sizeof(uint32_t); + } + +- unsigned int _serializeTimeValue(uint8_t *dest, timespec value) { ++ 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"); ++ 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 deserializeTimeValue_(const char **pos) { + timespec value{}; +- value.tv_sec = _deserialize<uint64_t>(pos); +- value.tv_nsec = _deserialize<uint32_t>(pos); ++ 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) { ++ 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) { ++ 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) { ++ unsigned int serializeBlockId_(uint8_t *dest, const BlockId &blockId) { + blockId.ToBinary(dest); + return blockId.BINARY_LENGTH; + } + +- BlockId _deserializeBlockId(const char **pos) { ++ BlockId deserializeBlockId_(const char **pos) { + BlockId blockId = BlockId::FromBinary(*pos); + *pos += BlockId::BINARY_LENGTH; + return blockId; +@@ -75,35 +75,35 @@ namespace cryfs { + _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); +- offset += _serializeString(dest + offset, _name); +- offset += _serializeBlockId(dest + offset, _blockId); ++ 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); ++ offset += serializeString_(dest + offset, _name); ++ offset += serializeBlockId_(dest + offset, _blockId); + ASSERT(offset == serializedSize(), "Didn't write correct number of elements"); + } + + const char *DirEntry::deserializeAndAddToVector(const char *pos, vector<DirEntry> *result) { +- fspp::Dir::EntryType type = static_cast<fspp::Dir::EntryType>(_deserialize<uint8_t>(&pos)); +- fspp::mode_t mode = fspp::mode_t(_deserialize<uint32_t>(&pos)); +- fspp::uid_t uid = fspp::uid_t(_deserialize<uint32_t>(&pos)); +- fspp::gid_t gid = fspp::gid_t(_deserialize<uint32_t>(&pos)); +- timespec lastAccessTime = _deserializeTimeValue(&pos); +- timespec lastModificationTime = _deserializeTimeValue(&pos); +- timespec lastMetadataChangeTime = _deserializeTimeValue(&pos); +- string name = _deserializeString(&pos); +- BlockId blockId = _deserializeBlockId(&pos); ++ fspp::Dir::EntryType type = static_cast<fspp::Dir::EntryType>(deserialize_<uint8_t>(&pos)); ++ fspp::mode_t mode = fspp::mode_t(deserialize_<uint32_t>(&pos)); ++ fspp::uid_t uid = fspp::uid_t(deserialize_<uint32_t>(&pos)); ++ fspp::gid_t gid = fspp::gid_t(deserialize_<uint32_t>(&pos)); ++ timespec lastAccessTime = deserializeTimeValue_(&pos); ++ timespec lastModificationTime = deserializeTimeValue_(&pos); ++ timespec lastMetadataChangeTime = deserializeTimeValue_(&pos); ++ string name = deserializeString_(&pos); ++ BlockId blockId = deserializeBlockId_(&pos); + + result->emplace_back(type, name, blockId, mode, uid, gid, lastAccessTime, lastModificationTime, lastMetadataChangeTime); + return pos; + } + + size_t DirEntry::serializedSize() const { +- return 1 + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + 3*_serializedTimeValueSize() + ( ++ return 1 + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + 3*serializedTimeValueSize_() + ( + _name.size() + 1) + _blockId.BINARY_LENGTH; + } + } +--- a/src/cryfs/localstate/LocalStateMetadata.cpp ++++ b/src/cryfs/localstate/LocalStateMetadata.cpp +@@ -30,10 +30,10 @@ LocalStateMetadata::LocalStateMetadata(uint32_t myClientId, Hash encryptionKeyHa + + LocalStateMetadata LocalStateMetadata::loadOrGenerate(const bf::path &statePath, const Data& encryptionKey, bool allowReplacedFilesystem) { + auto metadataFile = statePath / "metadata"; +- auto loaded = _load(metadataFile); ++ auto loaded = load_(metadataFile); + if (loaded == none) { + // If it couldn't be loaded, generate a new client id. +- return _generate(metadataFile, encryptionKey); ++ return generate_(metadataFile, encryptionKey); + } + + if (!allowReplacedFilesystem && loaded->_encryptionKeyHash.digest != cpputils::hash::hash(encryptionKey, loaded->_encryptionKeyHash.salt).digest) { +@@ -42,22 +42,22 @@ LocalStateMetadata LocalStateMetadata::loadOrGenerate(const bf::path &statePath, + return *loaded; + } + +-optional<LocalStateMetadata> LocalStateMetadata::_load(const bf::path &metadataFilePath) { ++optional<LocalStateMetadata> LocalStateMetadata::load_(const bf::path &metadataFilePath) { + ifstream file(metadataFilePath.string()); + if (!file.good()) { + // State file doesn't exist + return none; + } +- return _deserialize(file); ++ return deserialize_(file); + } + +-void LocalStateMetadata::_save(const bf::path &metadataFilePath) const { ++void LocalStateMetadata::save_(const bf::path &metadataFilePath) const { + ofstream file(metadataFilePath.string(), std::ios::trunc); +- _serialize(file); ++ serialize_(file); + } + + namespace { +-uint32_t _generateClientId() { ++uint32_t generateClientId_() { + uint32_t result; + do { + result = cpputils::deserialize<uint32_t>(Random::PseudoRandom().getFixedSize<sizeof(uint32_t)>().data()); +@@ -82,8 +82,8 @@ optional<uint32_t> _tryLoadClientIdFromLegacyFile(const bf::path &metadataFilePa + #endif + } + +-LocalStateMetadata LocalStateMetadata::_generate(const bf::path &metadataFilePath, const Data& encryptionKey) { +- uint32_t myClientId = _generateClientId(); ++LocalStateMetadata LocalStateMetadata::generate_(const bf::path &metadataFilePath, const Data& encryptionKey) { ++ uint32_t myClientId = generateClientId_(); + #ifndef CRYFS_NO_COMPATIBILITY + // In the old format, this was stored in a "myClientId" file. If that file exists, load it from there. + optional<uint32_t> legacy = _tryLoadClientIdFromLegacyFile(metadataFilePath); +@@ -93,11 +93,11 @@ LocalStateMetadata LocalStateMetadata::_generate(const bf::path &metadataFilePat + #endif + + LocalStateMetadata result(myClientId, cpputils::hash::hash(encryptionKey, cpputils::hash::generateSalt())); +- result._save(metadataFilePath); ++ result.save_(metadataFilePath); + return result; + } + +-void LocalStateMetadata::_serialize(ostream& stream) const { ++void LocalStateMetadata::serialize_(ostream& stream) const { + ptree pt; + pt.put<uint32_t>("myClientId", myClientId()); + pt.put<string>("encryptionKey.salt", _encryptionKeyHash.salt.ToString()); +@@ -106,7 +106,7 @@ void LocalStateMetadata::_serialize(ostream& stream) const { + write_json(stream, pt); + } + +-LocalStateMetadata LocalStateMetadata::_deserialize(istream& stream) { ++LocalStateMetadata LocalStateMetadata::deserialize_(istream& stream) { + try { + ptree pt; + read_json(stream, pt); +--- a/src/cryfs/localstate/LocalStateMetadata.h ++++ b/src/cryfs/localstate/LocalStateMetadata.h +@@ -20,11 +20,11 @@ class LocalStateMetadata final { + const uint32_t _myClientId; + const cpputils::hash::Hash _encryptionKeyHash; + +- static boost::optional<LocalStateMetadata> _load(const boost::filesystem::path &metadataFilePath); +- static LocalStateMetadata _deserialize(std::istream& stream); +- static LocalStateMetadata _generate(const boost::filesystem::path &metadataFilePath, const cpputils::Data& encryptionKey); +- void _save(const boost::filesystem::path &metadataFilePath) const; +- void _serialize(std::ostream& stream) const; ++ static boost::optional<LocalStateMetadata> load_(const boost::filesystem::path &metadataFilePath); ++ static LocalStateMetadata deserialize_(std::istream& stream); ++ static LocalStateMetadata generate_(const boost::filesystem::path &metadataFilePath, const cpputils::Data& encryptionKey); ++ void save_(const boost::filesystem::path &metadataFilePath) const; ++ void serialize_(std::ostream& stream) const; + + LocalStateMetadata(uint32_t myClientId, cpputils::hash::Hash encryptionKey); + };
