diff --git a/CMakeLists.txt b/CMakeLists.txt index 4c488d7f..3677beaf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -44,8 +44,8 @@ add_executable(hpcore src/sc/sc.cpp src/comm/comm_session.cpp src/msg/fbuf/common_helpers.cpp - src/msg/fbuf/p2pmsg_helpers.cpp src/msg/fbuf/ledger_helpers.cpp + src/msg/fbuf/p2pmsg_conversion.cpp src/msg/json/controlmsg_json.cpp src/msg/controlmsg_parser.cpp src/msg/json/usrmsg_json.cpp diff --git a/README.md b/README.md index 9edc872b..95701bcd 100644 --- a/README.md +++ b/README.md @@ -28,9 +28,9 @@ Run the setup script located at the repo root (tested on Ubuntu 18.04). ## FlatBuffers message definitions If you update flatbuffers message definitions, you need to run the flatbuffers code generator to update the stubs. -Example: When you make a change to `p2pmsg_content.fbc` defnition file, you need to run this: +Example: When you make a change to `p2pmsg.fbs` defnition file, you need to run this: -`flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg_content.fbs` +`flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg.fbs` ## Code structure Code is divided into subsystems via namespaces. diff --git a/src/consensus.cpp b/src/consensus.cpp index 46b402c4..bdf373be 100644 --- a/src/consensus.cpp +++ b/src/consensus.cpp @@ -4,7 +4,7 @@ #include "usr/usr.hpp" #include "usr/user_input.hpp" #include "p2p/p2p.hpp" -#include "msg/fbuf/p2pmsg_helpers.hpp" +#include "msg/fbuf/p2pmsg_conversion.hpp" #include "msg/usrmsg_parser.hpp" #include "msg/usrmsg_common.hpp" #include "p2p/peer_session_handler.hpp" @@ -400,7 +400,7 @@ namespace consensus } } - flatbuffers::FlatBufferBuilder fbuf(1024); + flatbuffers::FlatBufferBuilder fbuf; p2pmsg::create_msg_from_nonunl_proposal(fbuf, nup); p2p::broadcast_message(fbuf, true); @@ -418,7 +418,7 @@ namespace consensus if (conf::cfg.node.role == conf::ROLE::OBSERVER || !conf::cfg.node.is_unl) // If we are a non-unl node, do not broadcast proposals. return; - flatbuffers::FlatBufferBuilder fbuf(1024); + flatbuffers::FlatBufferBuilder fbuf; p2pmsg::create_msg_from_proposal(fbuf, p); p2p::broadcast_message(fbuf, true, false, !conf::cfg.contract.is_consensus_public); @@ -436,11 +436,11 @@ namespace consensus * @param npl_msg Constructed npl message. * @return Returns true if enqueue is success otherwise false. */ - bool push_npl_message(p2p::npl_message &npl_msg) + bool push_npl_message(const p2p::npl_message &npl_msg) { std::scoped_lock lock(ctx.contract_ctx_mutex); if (ctx.contract_ctx) - return ctx.contract_ctx->args.npl_messages.try_enqueue(npl_msg); + return ctx.contract_ctx->args.npl_messages.try_enqueue(std::move(npl_msg)); return false; } @@ -882,9 +882,6 @@ namespace consensus // lcl to be passed to the contract. args.lcl_id = new_lcl_id; - // This is currently used for npl message checks. - args.lasl_primary_shard_id = new_last_primary_shard_id; - // Populate user bufs. if (feed_user_inputs_to_contract_bufmap(args.userbufs, cons_prop) == -1) return -1; diff --git a/src/consensus.hpp b/src/consensus.hpp index 8d5678cf..35212e77 100644 --- a/src/consensus.hpp +++ b/src/consensus.hpp @@ -121,7 +121,7 @@ namespace consensus void broadcast_nonunl_proposal(); - bool push_npl_message(p2p::npl_message &npl_message); + bool push_npl_message(const p2p::npl_message &npl_message); int verify_and_populate_candidate_user_inputs(const uint64_t lcl_seq_no); diff --git a/src/hpfs/hpfs_serve.cpp b/src/hpfs/hpfs_serve.cpp index def9ebcc..521fd5e0 100644 --- a/src/hpfs/hpfs_serve.cpp +++ b/src/hpfs/hpfs_serve.cpp @@ -2,9 +2,7 @@ #include "../util/h32.hpp" #include "../util/util.hpp" #include "../p2p/p2p.hpp" -#include "../msg/fbuf/p2pmsg_content_generated.h" -#include "../msg/fbuf/p2pmsg_helpers.hpp" -#include "../msg/fbuf/common_helpers.hpp" +#include "../msg/fbuf/p2pmsg_conversion.hpp" #include "../ledger/ledger.hpp" #include "../hplog.hpp" #include "hpfs_serve.hpp" @@ -94,9 +92,9 @@ namespace hpfs // Session id is in binary format. Converting to hex before printing. LOG_DEBUG << "Serving hpfs request from [" << util::to_hex(session_id).substr(2, 10) << "]"; - flatbuffers::FlatBufferBuilder fbuf(1024); + flatbuffers::FlatBufferBuilder fbuf; - if (hpfs_serve::create_hpfs_response(fbuf, hr, last_primary_shard_id) == 1) + if (hpfs_serve::create_hpfs_response(fbuf, hr) == 1) { // Find the peer that we should send the hpfs response to. std::scoped_lock lock(p2p::ctx.peer_connections_mutex); @@ -125,11 +123,10 @@ namespace hpfs * Creates the reply message for a given hpfs request. * @param fbuf The flatbuffer builder to construct the reply message. * @param hr The hpfs request which should be replied to. - * @param last_primary_shard_id Last primary shard id. * @return 1 if successful hpfs response was generated. 0 if request is invalid * and no response was generated. -1 on error. */ - int hpfs_serve::create_hpfs_response(flatbuffers::FlatBufferBuilder &fbuf, const p2p::hpfs_request &hr, const p2p::sequence_hash &last_primary_shard_id) + int hpfs_serve::create_hpfs_response(flatbuffers::FlatBufferBuilder &fbuf, const p2p::hpfs_request &hr) { LOG_DEBUG << "Serving hpfs req. path:" << hr.parent_path << " block_id:" << hr.block_id; @@ -154,7 +151,7 @@ namespace hpfs resp.hash = hr.expected_hash; resp.data = std::string_view(reinterpret_cast(block.data()), block.size()); - msg::fbuf::p2pmsg::create_msg_from_block_response(fbuf, resp, fs_mount->mount_id, last_primary_shard_id); + p2pmsg::create_msg_from_block_response(fbuf, resp, fs_mount->mount_id); return 1; // Success. } } @@ -174,9 +171,9 @@ namespace hpfs } else if (result == 1) { - msg::fbuf::p2pmsg::create_msg_from_filehashmap_response( + p2pmsg::create_msg_from_filehashmap_response( fbuf, hr.parent_path, fs_mount->mount_id, block_hashes, - file_length, hr.expected_hash, last_primary_shard_id); + file_length, hr.expected_hash); return 1; // Success. } } @@ -194,8 +191,8 @@ namespace hpfs } else if (result == 1) { - msg::fbuf::p2pmsg::create_msg_from_fsentry_response( - fbuf, hr.parent_path, fs_mount->mount_id, child_hash_nodes, hr.expected_hash, last_primary_shard_id); + p2pmsg::create_msg_from_fsentry_response( + fbuf, hr.parent_path, fs_mount->mount_id, child_hash_nodes, hr.expected_hash); return 1; // Success. } } diff --git a/src/hpfs/hpfs_serve.hpp b/src/hpfs/hpfs_serve.hpp index 1604f7ac..ddb3dc81 100644 --- a/src/hpfs/hpfs_serve.hpp +++ b/src/hpfs/hpfs_serve.hpp @@ -4,7 +4,6 @@ #include "../util/h32.hpp" #include "hpfs_mount.hpp" #include "../p2p/p2p.hpp" -#include "../msg/fbuf/p2pmsg_content_generated.h" namespace hpfs { @@ -28,7 +27,7 @@ namespace hpfs void deinit(); - int create_hpfs_response(flatbuffers::FlatBufferBuilder &fbuf, const p2p::hpfs_request &hr, const p2p::sequence_hash &last_primary_shard_id); + int create_hpfs_response(flatbuffers::FlatBufferBuilder &fbuf, const p2p::hpfs_request &hr); int get_data_block(std::vector &block, const std::string_view vpath, const uint32_t block_id, const util::h32 expected_hash); diff --git a/src/hpfs/hpfs_sync.cpp b/src/hpfs/hpfs_sync.cpp index 1fedd9f7..64185938 100644 --- a/src/hpfs/hpfs_sync.cpp +++ b/src/hpfs/hpfs_sync.cpp @@ -1,15 +1,15 @@ -#include "../msg/fbuf/p2pmsg_helpers.hpp" -#include "../msg/fbuf/p2pmsg_content_generated.h" +#include "../pchheader.hpp" +#include "../msg/fbuf/p2pmsg_conversion.hpp" +#include "../msg/fbuf/p2pmsg_generated.h" #include "../msg/fbuf/common_helpers.hpp" #include "../p2p/p2p.hpp" -#include "../pchheader.hpp" -#include "../ledger/ledger.hpp" #include "../hplog.hpp" #include "../util/util.hpp" #include "../util/h32.hpp" +#include "../crypto.hpp" #include "hpfs_sync.hpp" -#include "../sc/sc.hpp" -#include "../unl.hpp" + +namespace p2pmsg = msg::fbuf::p2pmsg; namespace hpfs { @@ -209,10 +209,8 @@ namespace hpfs */ int hpfs_sync::request_loop(const util::h32 current_target_hash, util::h32 &updated_state) { - p2p::sequence_hash last_primary_shard_id = ledger::ctx.get_last_primary_shard_id(); - // Send the initial root hpfs request of the current target. - submit_request(backlog_item{current_target.item_type, current_target.vpath, -1, current_target_hash}, last_primary_shard_id); + submit_request(backlog_item{current_target.item_type, current_target.vpath, -1, current_target_hash}); // Indicates whether any responses were processed in the previous loop iteration. bool prev_responses_processed = false; @@ -226,9 +224,6 @@ namespace hpfs if (!prev_responses_processed) util::sleep(REQUEST_LOOP_WAIT); - // Get the current last shard information. - last_primary_shard_id = ledger::ctx.get_last_primary_shard_id(); - // Move the received hpfs responses to the local response list. swap_collected_responses(); @@ -245,12 +240,12 @@ namespace hpfs LOG_DEBUG << "Hpfs " << name << " sync: Processing hpfs response from [" << response.first.substr(2, 10) << "]"; - const msg::fbuf::p2pmsg::Content *content = msg::fbuf::p2pmsg::GetContent(response.second.data()); - const msg::fbuf::p2pmsg::Hpfs_Response_Message *resp_msg = content->message_as_Hpfs_Response_Message(); + const p2pmsg::P2PMsg &msg = *p2pmsg::GetP2PMsg(response.second.data()); + const p2pmsg::HpfsResponseMsg &resp_msg = *msg.content_as_HpfsResponseMsg(); // Check whether we are actually waiting for this response. If not, ignore it. - std::string_view hash = msg::fbuf::flatbuff_bytes_to_sv(resp_msg->hash()); - std::string_view vpath = msg::fbuf::flatbuff_str_to_sv(resp_msg->path()); + std::string_view hash = msg::fbuf::flatbuf_bytes_to_sv(resp_msg.hash()); + std::string_view vpath = msg::fbuf::flatbuf_str_to_sv(resp_msg.path()); const std::string key = std::string(vpath).append(hash); const auto pending_resp_itr = submitted_requests.find(key); @@ -261,15 +256,15 @@ namespace hpfs } // Process the message based on response type. - const msg::fbuf::p2pmsg::Hpfs_Response msg_type = resp_msg->hpfs_response_type(); + const p2pmsg::HpfsResponse msg_type = resp_msg.content_type(); - if (msg_type == msg::fbuf::p2pmsg::Hpfs_Response_Fs_Entry_Response) + if (msg_type == p2pmsg::HpfsResponse_HpfsFsEntryResponse) { - const msg::fbuf::p2pmsg::Fs_Entry_Response *fs_resp = resp_msg->hpfs_response_as_Fs_Entry_Response(); + const p2pmsg::HpfsFsEntryResponse &fs_resp = *resp_msg.content_as_HpfsFsEntryResponse(); // Get fs entries we have received. std::unordered_map peer_fs_entry_map; - msg::fbuf::p2pmsg::flatbuf_hpfsfshashentry_to_hpfsfshashentry(peer_fs_entry_map, fs_resp->entries()); + p2pmsg::flatbuf_hpfsfshashentry_to_hpfsfshashentry(peer_fs_entry_map, fs_resp.entries()); // Commented for now. Need to change the way the hash is calculated once the flatbuffer re-architecture finishes. // Validate received fs data against the hash. @@ -281,13 +276,13 @@ namespace hpfs handle_fs_entry_response(vpath, peer_fs_entry_map); } - else if (msg_type == msg::fbuf::p2pmsg::Hpfs_Response_File_HashMap_Response) + else if (msg_type == p2pmsg::HpfsResponse_HpfsFileHashMapResponse) { - const msg::fbuf::p2pmsg::File_HashMap_Response *file_resp = resp_msg->hpfs_response_as_File_HashMap_Response(); + const p2pmsg::HpfsFileHashMapResponse &file_resp = *resp_msg.content_as_HpfsFileHashMapResponse(); // File block hashes we received from the peer. - const util::h32 *peer_hashes = reinterpret_cast(file_resp->hash_map()->data()); - const size_t peer_hash_count = file_resp->hash_map()->size() / sizeof(util::h32); + const util::h32 *peer_hashes = reinterpret_cast(file_resp.hash_map()->data()); + const size_t peer_hash_count = file_resp.hash_map()->size() / sizeof(util::h32); // Commented for now. Need to change the way the hash is calculated once the flatbuffer re-architecture finishes. // Validate received hashmap against the hash. @@ -297,15 +292,15 @@ namespace hpfs // continue; // } - handle_file_hashmap_response(vpath, peer_hashes, peer_hash_count, file_resp->file_length()); + handle_file_hashmap_response(vpath, peer_hashes, peer_hash_count, file_resp.file_length()); } - else if (msg_type == msg::fbuf::p2pmsg::Hpfs_Response_Block_Response) + else if (msg_type == p2pmsg::HpfsResponse_HpfsBlockResponse) { - const msg::fbuf::p2pmsg::Block_Response *block_resp = resp_msg->hpfs_response_as_Block_Response(); + const p2pmsg::HpfsBlockResponse &block_resp = *resp_msg.content_as_HpfsBlockResponse(); // Get the file path of the block data we have received. - const uint32_t block_id = block_resp->block_id(); - std::string_view buf = msg::fbuf::flatbuff_bytes_to_sv(block_resp->data()); + const uint32_t block_id = block_resp.block_id(); + std::string_view buf = msg::fbuf::flatbuf_bytes_to_sv(block_resp.data()); // Commented for now. Need to change the way the hash is calculated once the flatbuffer re-architecture finishes. // Validate received block data against the hash. @@ -373,7 +368,7 @@ namespace hpfs // Reset the counter and re-submit request. request.waiting_time = 0; LOG_DEBUG << "Hpfs " << name << " sync: Resubmitting request..."; - submit_request(request, last_primary_shard_id); + submit_request(request); } } @@ -387,7 +382,7 @@ namespace hpfs return 0; const backlog_item &request = pending_requests.front(); - submit_request(request, last_primary_shard_id); + submit_request(request); pending_requests.pop_front(); } } @@ -480,11 +475,10 @@ namespace hpfs * @param is_file Whether the requested path if a file or dir. * @param block_id The requested block id. Only relevant if requesting a file block. Otherwise -1. * @param expected_hash The expected hash of the requested data. The peer will ignore the request if their hash is different. - * @param last_primary_shard_id The last primary shard id. * @param target_pubkey The peer pubkey the request was submitted to. */ void hpfs_sync::request_state_from_peer(const std::string &path, const bool is_file, const int32_t block_id, - const util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id, std::string &target_pubkey) + const util::h32 expected_hash, std::string &target_pubkey) { p2p::hpfs_request hr; hr.parent_path = path; @@ -493,15 +487,15 @@ namespace hpfs hr.expected_hash = expected_hash; hr.mount_id = fs_mount->mount_id; - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_hpfs_request(fbuf, hr, last_primary_shard_id); - p2p::send_message_to_random_peer(fbuf, target_pubkey); //todo: send to a node that hold the majority hpfs state to improve reliability of retrieving hpfs state. + flatbuffers::FlatBufferBuilder fbuf; + p2pmsg::create_msg_from_hpfs_request(fbuf, hr); + p2p::send_message_to_random_peer(fbuf, target_pubkey); //todo: send to a node that hold the expected hash to improve reliability of retrieving hpfs state. } /** * Submits a pending hpfs request to the peer. */ - void hpfs_sync::submit_request(const backlog_item &request, const p2p::sequence_hash &last_primary_shard_id) + void hpfs_sync::submit_request(const backlog_item &request) { const std::string key = std::string(request.path) .append(reinterpret_cast(&request.expected_hash), sizeof(util::h32)); @@ -509,7 +503,7 @@ namespace hpfs const bool is_file = request.type != BACKLOG_ITEM_TYPE::DIR; std::string target_pubkey; - request_state_from_peer(request.path, is_file, request.block_id, request.expected_hash, last_primary_shard_id, target_pubkey); + request_state_from_peer(request.path, is_file, request.block_id, request.expected_hash, target_pubkey); if (!target_pubkey.empty()) LOG_DEBUG << "Hpfs " << name << " sync: Requesting from [" << target_pubkey.substr(2, 10) << "]. type:" << request.type diff --git a/src/hpfs/hpfs_sync.hpp b/src/hpfs/hpfs_sync.hpp index 123eaa6b..ab7ad72b 100644 --- a/src/hpfs/hpfs_sync.hpp +++ b/src/hpfs/hpfs_sync.hpp @@ -3,9 +3,7 @@ #include "../pchheader.hpp" #include "../p2p/p2p.hpp" -#include "../msg/fbuf/p2pmsg_content_generated.h" #include "../util/h32.hpp" -#include "../crypto.hpp" #include "./hpfs_mount.hpp" namespace hpfs @@ -109,9 +107,9 @@ namespace hpfs bool should_stop_request_loop(const util::h32 ¤t_target_hash); void request_state_from_peer(const std::string &path, const bool is_file, const int32_t block_id, - const util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id, std::string &target_pubkey); + const util::h32 expected_hash, std::string &target_pubkey); - void submit_request(const backlog_item &request, const p2p::sequence_hash &last_primary_shard_id); + void submit_request(const backlog_item &request); int handle_fs_entry_response(std::string_view vpath, std::unordered_map &fs_entry_map); diff --git a/src/msg/fbuf/common_helpers.cpp b/src/msg/fbuf/common_helpers.cpp index 34440476..1568294a 100644 --- a/src/msg/fbuf/common_helpers.cpp +++ b/src/msg/fbuf/common_helpers.cpp @@ -3,123 +3,54 @@ namespace msg::fbuf { - //---Conversion helpers from flatbuffers data types to std data types---// + //---Flatbuf to std---// - /** - * Returns string_view from flat buffer data pointer and length. - */ - std::string_view flatbuff_bytes_to_sv(const uint8_t *data, const flatbuffers::uoffset_t length) + std::string_view flatbuf_bytes_to_sv(const uint8_t *data, const flatbuffers::uoffset_t length) { const char *signature_content_str = reinterpret_cast(data); return std::string_view(signature_content_str, length); } - /** - * Returns string_view from Flat Buffer vector of bytes. - */ - std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector *buffer) + std::string_view flatbuf_bytes_to_sv(const flatbuffers::Vector *buffer) { - return flatbuff_bytes_to_sv(buffer->Data(), buffer->size()); + return flatbuf_bytes_to_sv(buffer->Data(), buffer->size()); } - /** - * Returns return string_view from Flat Buffer string. - */ - std::string_view flatbuff_str_to_sv(const flatbuffers::String *buffer) + std::string_view flatbuf_str_to_sv(const flatbuffers::String *buffer) { - return flatbuff_bytes_to_sv(buffer->Data(), buffer->size()); + return flatbuf_bytes_to_sv(buffer->Data(), buffer->size()); } - /** - * Returns hash from Flat Buffer vector of bytes. - */ - util::h32 flatbuff_bytes_to_hash(const flatbuffers::Vector *buffer) + util::h32 flatbuf_bytes_to_hash(const flatbuffers::Vector *buffer) { return *reinterpret_cast(buffer->data()); } - /** - * Returns set from Flatbuffer vector of ByteArrays. - */ - const std::set flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector> *fbvec) + std::string_view builder_to_string_view(const flatbuffers::FlatBufferBuilder &builder) { - std::set set; - for (auto el : *fbvec) - set.emplace(std::string(flatbuff_bytes_to_sv(el->array()))); - return set; + std::string_view msg = std::string_view( + reinterpret_cast(builder.GetBufferPointer()), builder.GetSize()); + return msg; } - /** - * Returns a map from Flatbuffer vector of key value pairs. - */ - const std::unordered_map - flatbuf_pairvector_to_stringmap(const flatbuffers::Vector> *fbvec) - { - std::unordered_map map; - map.reserve(fbvec->size()); - for (auto el : *fbvec) - map.emplace(flatbuff_bytes_to_sv(el->key()), flatbuff_bytes_to_sv(el->value())); - return map; - } + //---std to Flatbuf---// - //---Conversion helpers from std data types to flatbuffers data types---// - //---These are used in constructing Flatbuffer messages using builders---// - - /** - * Returns Flatbuffer bytes vector from string_view. - */ const flatbuffers::Offset> - sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv) + sv_to_flatbuf_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv) { return builder.CreateVector(reinterpret_cast(sv.data()), sv.size()); } - /** - * Returns Flatbuffer string from string_view. - */ const flatbuffers::Offset - sv_to_flatbuff_str(flatbuffers::FlatBufferBuilder &builder, std::string_view sv) + sv_to_flatbuf_str(flatbuffers::FlatBufferBuilder &builder, std::string_view sv) { return builder.CreateString(sv); } - /** - * Returns Flatbuffer bytes vector from hash. - */ const flatbuffers::Offset> - hash_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, const util::h32 hash) + hash_to_flatbuf_bytes(flatbuffers::FlatBufferBuilder &builder, const util::h32 hash) { return builder.CreateVector(reinterpret_cast(&hash), sizeof(util::h32)); } - /** - * Returns Flatbuffer vector of ByteArrays from given set of strings. - */ - const flatbuffers::Offset>> - stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::set &set) - { - std::vector> fbvec; - fbvec.reserve(set.size()); - for (std::string_view str : set) - fbvec.push_back(CreateByteArray(builder, sv_to_flatbuff_bytes(builder, str))); - return builder.CreateVector(fbvec); - } - - /** - * Returns Flatbuffer vector of key value pairs from given map. - */ - const flatbuffers::Offset>> - stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map &map) - { - std::vector> fbvec; - fbvec.reserve(map.size()); - for (auto const &[key, value] : map) - { - fbvec.push_back(CreateBytesKeyValuePair( - builder, - sv_to_flatbuff_bytes(builder, key), - sv_to_flatbuff_bytes(builder, value))); - } - return builder.CreateVector(fbvec); - } } // namespace msg::fbuf \ No newline at end of file diff --git a/src/msg/fbuf/common_helpers.hpp b/src/msg/fbuf/common_helpers.hpp index 1653a40f..a1eb52ae 100644 --- a/src/msg/fbuf/common_helpers.hpp +++ b/src/msg/fbuf/common_helpers.hpp @@ -3,46 +3,36 @@ #include "../../pchheader.hpp" #include "../../util/h32.hpp" -#include "common_schema_generated.h" +#include "p2pmsg_generated.h" namespace msg::fbuf { /** - * This section contains common Flatbuffer message reading/writing helpers. - */ + * This section contains common Flatbuffer message reading/writing helpers. + */ - //---Conversion helpers from flatbuffers data types to std data types---// + //---Flatbuf to std---// - std::string_view flatbuff_bytes_to_sv(const uint8_t *data, const flatbuffers::uoffset_t length); + std::string_view flatbuf_bytes_to_sv(const uint8_t *data, const flatbuffers::uoffset_t length); - std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector *buffer); + std::string_view flatbuf_bytes_to_sv(const flatbuffers::Vector *buffer); - std::string_view flatbuff_str_to_sv(const flatbuffers::String *buffer); + std::string_view flatbuf_str_to_sv(const flatbuffers::String *buffer); - util::h32 flatbuff_bytes_to_hash(const flatbuffers::Vector *buffer); + util::h32 flatbuf_bytes_to_hash(const flatbuffers::Vector *buffer); - const std::set - flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector> *fbvec); + std::string_view builder_to_string_view(const flatbuffers::FlatBufferBuilder &builder); - const std::unordered_map - flatbuf_pairvector_to_stringmap(const flatbuffers::Vector> *fbvec); - - //---Conversion helpers from std data types to flatbuffers data types---// + //---std to Flatbuf---// const flatbuffers::Offset> - sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv); + sv_to_flatbuf_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv); const flatbuffers::Offset - sv_to_flatbuff_str(flatbuffers::FlatBufferBuilder &builder, std::string_view sv); + sv_to_flatbuf_str(flatbuffers::FlatBufferBuilder &builder, std::string_view sv); const flatbuffers::Offset> - hash_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, util::h32 hash); - - const flatbuffers::Offset>> - stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::set &set); - - const flatbuffers::Offset>> - stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map &map); + hash_to_flatbuf_bytes(flatbuffers::FlatBufferBuilder &builder, util::h32 hash); } // namespace msg::fbuf diff --git a/src/msg/fbuf/common_schema.fbs b/src/msg/fbuf/common_schema.fbs deleted file mode 100644 index 1628e6bd..00000000 --- a/src/msg/fbuf/common_schema.fbs +++ /dev/null @@ -1,11 +0,0 @@ -//IDL file for common types. -namespace msg.fbuf; - -table BytesKeyValuePair { //A key, value pair of byte[]. - key:[ubyte]; - value:[ubyte]; -} - -table ByteArray { //To represent list of byte arrays - array:[ubyte]; -} diff --git a/src/msg/fbuf/common_schema_generated.h b/src/msg/fbuf/common_schema_generated.h deleted file mode 100644 index f3351c6f..00000000 --- a/src/msg/fbuf/common_schema_generated.h +++ /dev/null @@ -1,146 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ -#define FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ - -#include "flatbuffers/flatbuffers.h" - -namespace msg { -namespace fbuf { - -struct BytesKeyValuePair; -struct BytesKeyValuePairBuilder; - -struct ByteArray; -struct ByteArrayBuilder; - -struct BytesKeyValuePair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef BytesKeyValuePairBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEY = 4, - VT_VALUE = 6 - }; - const flatbuffers::Vector *key() const { - return GetPointer *>(VT_KEY); - } - flatbuffers::Vector *mutable_key() { - return GetPointer *>(VT_KEY); - } - const flatbuffers::Vector *value() const { - return GetPointer *>(VT_VALUE); - } - flatbuffers::Vector *mutable_value() { - return GetPointer *>(VT_VALUE); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_KEY) && - verifier.VerifyVector(key()) && - VerifyOffset(verifier, VT_VALUE) && - verifier.VerifyVector(value()) && - verifier.EndTable(); - } -}; - -struct BytesKeyValuePairBuilder { - typedef BytesKeyValuePair Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_key(flatbuffers::Offset> key) { - fbb_.AddOffset(BytesKeyValuePair::VT_KEY, key); - } - void add_value(flatbuffers::Offset> value) { - fbb_.AddOffset(BytesKeyValuePair::VT_VALUE, value); - } - explicit BytesKeyValuePairBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateBytesKeyValuePair( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> key = 0, - flatbuffers::Offset> value = 0) { - BytesKeyValuePairBuilder builder_(_fbb); - builder_.add_value(value); - builder_.add_key(key); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateBytesKeyValuePairDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *key = nullptr, - const std::vector *value = nullptr) { - auto key__ = key ? _fbb.CreateVector(*key) : 0; - auto value__ = value ? _fbb.CreateVector(*value) : 0; - return msg::fbuf::CreateBytesKeyValuePair( - _fbb, - key__, - value__); -} - -struct ByteArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ByteArrayBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ARRAY = 4 - }; - const flatbuffers::Vector *array() const { - return GetPointer *>(VT_ARRAY); - } - flatbuffers::Vector *mutable_array() { - return GetPointer *>(VT_ARRAY); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ARRAY) && - verifier.VerifyVector(array()) && - verifier.EndTable(); - } -}; - -struct ByteArrayBuilder { - typedef ByteArray Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_array(flatbuffers::Offset> array) { - fbb_.AddOffset(ByteArray::VT_ARRAY, array); - } - explicit ByteArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateByteArray( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> array = 0) { - ByteArrayBuilder builder_(_fbb); - builder_.add_array(array); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateByteArrayDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *array = nullptr) { - auto array__ = array ? _fbb.CreateVector(*array) : 0; - return msg::fbuf::CreateByteArray( - _fbb, - array__); -} - -} // namespace fbuf -} // namespace msg - -#endif // FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ diff --git a/src/msg/fbuf/flatbuf_hasher.hpp b/src/msg/fbuf/flatbuf_hasher.hpp new file mode 100644 index 00000000..664bdb7b --- /dev/null +++ b/src/msg/fbuf/flatbuf_hasher.hpp @@ -0,0 +1,89 @@ +#ifndef _HP_MSG_FBUF_FBUF_HASHER +#define _HP_MSG_FBUF_FBUF_HASHER + +#include "../../pchheader.hpp" +#include "../../util/util.hpp" +#include "p2pmsg_generated.h" + +namespace msg::fbuf::p2pmsg +{ + class flatbuf_hasher + { + private: + blake3_hasher hasher; + + public: + flatbuf_hasher() + { + blake3_hasher_init(&hasher); + } + + void add(const uint8_t i) + { + blake3_hasher_update(&hasher, &i, sizeof(uint8_t)); + } + + void add(const uint32_t i) + { + uint8_t bytes[4]; + util::uint32_to_bytes(bytes, i); + blake3_hasher_update(&hasher, bytes, sizeof(bytes)); + } + + void add(const uint64_t i) + { + uint8_t bytes[8]; + util::uint64_to_bytes(bytes, i); + blake3_hasher_update(&hasher, bytes, sizeof(bytes)); + } + + void add(std::string_view sv) + { + blake3_hasher_update(&hasher, sv.data(), sv.size()); + } + + void add(const std::set &sl) + { + for(const std::string &s : sl) + add(s); + } + + void add(const flatbuffers::Vector *v) + { + blake3_hasher_update(&hasher, v->data(), v->size()); + } + + void add(const flatbuffers::Vector> *v) + { + for (const auto el : *v) + add(el->array()); + } + + void add(const util::h32 &h) + { + add(h.to_string_view()); + } + + void add(const p2p::sequence_hash &h) + { + add(h.seq_no); + add(h.hash); + } + + void add(const SequenceHash *h) + { + add(h->seq_no()); + add(h->hash()); + } + + const std::string hash() + { + std::string hash; + hash.resize(BLAKE3_OUT_LEN); + blake3_hasher_finalize(&hasher, reinterpret_cast(hash.data()), hash.size()); + return hash; + } + }; +} + +#endif \ No newline at end of file diff --git a/src/msg/fbuf/ledger_helpers.cpp b/src/msg/fbuf/ledger_helpers.cpp index 7111cc2b..fc938e8c 100644 --- a/src/msg/fbuf/ledger_helpers.cpp +++ b/src/msg/fbuf/ledger_helpers.cpp @@ -1,6 +1,5 @@ #include "../../pchheader.hpp" #include "../../p2p/p2p.hpp" -#include "ledger_schema_generated.h" #include "ledger_blob_schema_generated.h" #include "common_helpers.hpp" #include "ledger_helpers.hpp" @@ -24,11 +23,11 @@ namespace msg::fbuf::ledgermsg inputs.reserve(value.size()); for (const auto &input : value) - inputs.push_back(ledgermsg::CreateRawInput(builder, sv_to_flatbuff_bytes(builder, input))); - + inputs.push_back(ledgermsg::CreateRawInput(builder, sv_to_flatbuf_bytes(builder, input))); + raw_inputs.push_back(ledgermsg::CreateRawInputCollection( builder, - sv_to_flatbuff_bytes(builder, key), + sv_to_flatbuf_bytes(builder, key), builder.CreateVector(inputs))); } @@ -38,18 +37,18 @@ namespace msg::fbuf::ledgermsg outputs.reserve(value.size()); for (const auto &output : value) - outputs.push_back(ledgermsg::CreateRawOutput(builder, sv_to_flatbuff_bytes(builder, output))); - + outputs.push_back(ledgermsg::CreateRawOutput(builder, sv_to_flatbuf_bytes(builder, output))); + raw_outputs.push_back(ledgermsg::CreateRawOutputCollection( builder, - sv_to_flatbuff_bytes(builder, key), + sv_to_flatbuf_bytes(builder, key), builder.CreateVector(outputs))); } flatbuffers::Offset blob = ledgermsg::CreateLedgerBlob( builder, - hash_to_flatbuff_bytes(builder, ledger_blob.ledger_hash), + hash_to_flatbuf_bytes(builder, ledger_blob.ledger_hash), builder.CreateVector(raw_inputs), builder.CreateVector(raw_outputs)); diff --git a/src/msg/fbuf/ledger_helpers.hpp b/src/msg/fbuf/ledger_helpers.hpp index 29910600..d92531d4 100644 --- a/src/msg/fbuf/ledger_helpers.hpp +++ b/src/msg/fbuf/ledger_helpers.hpp @@ -4,7 +4,6 @@ #include "../../pchheader.hpp" #include "../../p2p/p2p.hpp" #include "../../ledger/ledger.hpp" -#include "ledger_schema_generated.h" namespace msg::fbuf::ledgermsg { diff --git a/src/msg/fbuf/ledger_schema.fbs b/src/msg/fbuf/ledger_schema.fbs deleted file mode 100644 index f9e61205..00000000 --- a/src/msg/fbuf/ledger_schema.fbs +++ /dev/null @@ -1,17 +0,0 @@ -include "common_schema.fbs"; - -namespace msg.fbuf.ledgermsg; - -table LedgerBlock { - version:string; - seq_no:uint64; - time:uint64; - lcl:[ubyte]; - state_hash:[ubyte]; - patch_hash:[ubyte]; - users: [ByteArray]; - inputs: [ByteArray]; - output: [ubyte]; -} - -root_type LedgerBlock; \ No newline at end of file diff --git a/src/msg/fbuf/ledger_schema_generated.h b/src/msg/fbuf/ledger_schema_generated.h deleted file mode 100644 index 6edd8b46..00000000 --- a/src/msg/fbuf/ledger_schema_generated.h +++ /dev/null @@ -1,244 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_ -#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_ - -#include "flatbuffers/flatbuffers.h" - -#include "common_schema_generated.h" - -namespace msg { -namespace fbuf { -namespace ledgermsg { - -struct LedgerBlock; -struct LedgerBlockBuilder; - -struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef LedgerBlockBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_VERSION = 4, - VT_SEQ_NO = 6, - VT_TIME = 8, - VT_LCL = 10, - VT_STATE_HASH = 12, - VT_PATCH_HASH = 14, - VT_USERS = 16, - VT_INPUTS = 18, - VT_OUTPUT = 20 - }; - const flatbuffers::String *version() const { - return GetPointer(VT_VERSION); - } - flatbuffers::String *mutable_version() { - return GetPointer(VT_VERSION); - } - uint64_t seq_no() const { - return GetField(VT_SEQ_NO, 0); - } - bool mutate_seq_no(uint64_t _seq_no) { - return SetField(VT_SEQ_NO, _seq_no, 0); - } - uint64_t time() const { - return GetField(VT_TIME, 0); - } - bool mutate_time(uint64_t _time) { - return SetField(VT_TIME, _time, 0); - } - const flatbuffers::Vector *lcl() const { - return GetPointer *>(VT_LCL); - } - flatbuffers::Vector *mutable_lcl() { - return GetPointer *>(VT_LCL); - } - const flatbuffers::Vector *state_hash() const { - return GetPointer *>(VT_STATE_HASH); - } - flatbuffers::Vector *mutable_state_hash() { - return GetPointer *>(VT_STATE_HASH); - } - const flatbuffers::Vector *patch_hash() const { - return GetPointer *>(VT_PATCH_HASH); - } - flatbuffers::Vector *mutable_patch_hash() { - return GetPointer *>(VT_PATCH_HASH); - } - const flatbuffers::Vector> *users() const { - return GetPointer> *>(VT_USERS); - } - flatbuffers::Vector> *mutable_users() { - return GetPointer> *>(VT_USERS); - } - const flatbuffers::Vector> *inputs() const { - return GetPointer> *>(VT_INPUTS); - } - flatbuffers::Vector> *mutable_inputs() { - return GetPointer> *>(VT_INPUTS); - } - const flatbuffers::Vector *output() const { - return GetPointer *>(VT_OUTPUT); - } - flatbuffers::Vector *mutable_output() { - return GetPointer *>(VT_OUTPUT); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_VERSION) && - verifier.VerifyString(version()) && - VerifyField(verifier, VT_SEQ_NO) && - VerifyField(verifier, VT_TIME) && - VerifyOffset(verifier, VT_LCL) && - verifier.VerifyVector(lcl()) && - VerifyOffset(verifier, VT_STATE_HASH) && - verifier.VerifyVector(state_hash()) && - VerifyOffset(verifier, VT_PATCH_HASH) && - verifier.VerifyVector(patch_hash()) && - VerifyOffset(verifier, VT_USERS) && - verifier.VerifyVector(users()) && - verifier.VerifyVectorOfTables(users()) && - VerifyOffset(verifier, VT_INPUTS) && - verifier.VerifyVector(inputs()) && - verifier.VerifyVectorOfTables(inputs()) && - VerifyOffset(verifier, VT_OUTPUT) && - verifier.VerifyVector(output()) && - verifier.EndTable(); - } -}; - -struct LedgerBlockBuilder { - typedef LedgerBlock Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_version(flatbuffers::Offset version) { - fbb_.AddOffset(LedgerBlock::VT_VERSION, version); - } - void add_seq_no(uint64_t seq_no) { - fbb_.AddElement(LedgerBlock::VT_SEQ_NO, seq_no, 0); - } - void add_time(uint64_t time) { - fbb_.AddElement(LedgerBlock::VT_TIME, time, 0); - } - void add_lcl(flatbuffers::Offset> lcl) { - fbb_.AddOffset(LedgerBlock::VT_LCL, lcl); - } - void add_state_hash(flatbuffers::Offset> state_hash) { - fbb_.AddOffset(LedgerBlock::VT_STATE_HASH, state_hash); - } - void add_patch_hash(flatbuffers::Offset> patch_hash) { - fbb_.AddOffset(LedgerBlock::VT_PATCH_HASH, patch_hash); - } - void add_users(flatbuffers::Offset>> users) { - fbb_.AddOffset(LedgerBlock::VT_USERS, users); - } - void add_inputs(flatbuffers::Offset>> inputs) { - fbb_.AddOffset(LedgerBlock::VT_INPUTS, inputs); - } - void add_output(flatbuffers::Offset> output) { - fbb_.AddOffset(LedgerBlock::VT_OUTPUT, output); - } - explicit LedgerBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateLedgerBlock( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset version = 0, - uint64_t seq_no = 0, - uint64_t time = 0, - flatbuffers::Offset> lcl = 0, - flatbuffers::Offset> state_hash = 0, - flatbuffers::Offset> patch_hash = 0, - flatbuffers::Offset>> users = 0, - flatbuffers::Offset>> inputs = 0, - flatbuffers::Offset> output = 0) { - LedgerBlockBuilder builder_(_fbb); - builder_.add_time(time); - builder_.add_seq_no(seq_no); - builder_.add_output(output); - builder_.add_inputs(inputs); - builder_.add_users(users); - builder_.add_patch_hash(patch_hash); - builder_.add_state_hash(state_hash); - builder_.add_lcl(lcl); - builder_.add_version(version); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateLedgerBlockDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *version = nullptr, - uint64_t seq_no = 0, - uint64_t time = 0, - const std::vector *lcl = nullptr, - const std::vector *state_hash = nullptr, - const std::vector *patch_hash = nullptr, - const std::vector> *users = nullptr, - const std::vector> *inputs = nullptr, - const std::vector *output = nullptr) { - auto version__ = version ? _fbb.CreateString(version) : 0; - auto lcl__ = lcl ? _fbb.CreateVector(*lcl) : 0; - auto state_hash__ = state_hash ? _fbb.CreateVector(*state_hash) : 0; - auto patch_hash__ = patch_hash ? _fbb.CreateVector(*patch_hash) : 0; - auto users__ = users ? _fbb.CreateVector>(*users) : 0; - auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; - auto output__ = output ? _fbb.CreateVector(*output) : 0; - return msg::fbuf::ledgermsg::CreateLedgerBlock( - _fbb, - version__, - seq_no, - time, - lcl__, - state_hash__, - patch_hash__, - users__, - inputs__, - output__); -} - -inline const msg::fbuf::ledgermsg::LedgerBlock *GetLedgerBlock(const void *buf) { - return flatbuffers::GetRoot(buf); -} - -inline const msg::fbuf::ledgermsg::LedgerBlock *GetSizePrefixedLedgerBlock(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); -} - -inline LedgerBlock *GetMutableLedgerBlock(void *buf) { - return flatbuffers::GetMutableRoot(buf); -} - -inline bool VerifyLedgerBlockBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); -} - -inline bool VerifySizePrefixedLedgerBlockBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); -} - -inline void FinishLedgerBlockBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedLedgerBlockBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.FinishSizePrefixed(root); -} - -} // namespace ledgermsg -} // namespace fbuf -} // namespace msg - -#endif // FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_ diff --git a/src/msg/fbuf/p2pmsg.fbs b/src/msg/fbuf/p2pmsg.fbs new file mode 100644 index 00000000..ded99ad3 --- /dev/null +++ b/src/msg/fbuf/p2pmsg.fbs @@ -0,0 +1,154 @@ +// IDL file for p2p message definitions. +// flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg.fbs + +namespace msg.fbuf.p2pmsg; + +union P2PMsgContent { + PeerChallengeMsg, + PeerChallengeResponseMsg, + NonUnlProposalMsg, + ProposalMsg, + NplMsg, + HpfsRequestMsg, + HpfsResponseMsg, + PeerRequirementAnnouncementMsg, + PeerCapacityAnnouncementMsg, + PeerListRequestMsg, + PeerListResponseMsg +} + +table P2PMsg { + hp_version:string; + created_on:uint64; + content:P2PMsgContent; +} + +table PeerChallengeMsg { + contract_id:string; + roundtime:uint32; + challenge:[ubyte]; +} + +table PeerChallengeResponseMsg { + challenge:[ubyte]; + pubkey:[ubyte]; + sig:[ubyte]; +} + +table UserInput { + input_container:[ubyte]; + sig:[ubyte]; + protocol:uint8; +} + +table UserInputGroup { + pubkey:[ubyte]; + messages:[UserInput]; +} + +table NonUnlProposalMsg { + user_inputs:[UserInputGroup]; +} + +table ProposalMsg { + pubkey:[ubyte]; // Sender pubkey. + sig:[ubyte]; // Signature of the field data. + stage:uint8; + time:uint64; + roundtime:uint32; + nonce: [ubyte]; + users:[ByteArray]; + input_hashes:[ByteArray]; + output_hash:[ubyte]; + output_sig:[ubyte]; + state_hash: [ubyte]; + patch_hash: [ubyte]; + last_primary_shard_id:SequenceHash; + last_blob_shard_id: SequenceHash; + + // Make sure to update signature generation/verification whenever these fields are changed. +} + +table NplMsg { + pubkey:[ubyte]; // Sender pubkey. + sig:[ubyte]; // Signature of the field data. + data:[ubyte]; + lcl_id:SequenceHash; + + // Make sure to update signature generation/verification whenever these fields are changed. +} + +table HpfsRequestMsg { + mount_id: uint32; + parent_path:string; + is_file:bool; + block_id:int32; + expected_hash:[ubyte]; +} + +union HpfsResponse { + HpfsFileHashMapResponse, + HpfsBlockResponse, + HpfsFsEntryResponse +} + +table HpfsResponseMsg{ + hash:[ubyte]; + path: string; + mount_id: uint32; + content:HpfsResponse; +} + +table HpfsFsEntryResponse{ + entries: [HpfsFSHashEntry]; +} + +table HpfsFileHashMapResponse{ + file_length:uint64; + hash_map:[ubyte]; +} + +table HpfsBlockResponse{ + block_id:uint32; + data: [ubyte]; +} + +table HpfsFSHashEntry{ + name: string; + is_file: bool; + hash: [ubyte]; +} + +table PeerRequirementAnnouncementMsg{ + need_consensus_msg_forwarding: bool; +} + +table PeerCapacityAnnouncementMsg{ + available_capacity:int16; + timestamp:uint64; +} + +table PeerListRequestMsg{ +} + +table PeerListResponseMsg{ + peer_list: [PeerProperties]; +} + +table PeerProperties { + host_address:string; + port:uint16; + available_capacity:int16; + timestamp:uint64; +} + +table SequenceHash { + seq_no: uint64; + hash: [ubyte]; +} + +table ByteArray { // To help represent list of byte arrays + array:[ubyte]; +} + +root_type P2PMsg; //root type for all messages \ No newline at end of file diff --git a/src/msg/fbuf/p2pmsg_container.fbs b/src/msg/fbuf/p2pmsg_container.fbs deleted file mode 100644 index a502c231..00000000 --- a/src/msg/fbuf/p2pmsg_container.fbs +++ /dev/null @@ -1,18 +0,0 @@ -//IDL file for p2p message container schema. -/*Message content need to be serialised and parsed into container, we need two root types in flatbuffs to generat - needed api methods. Since Flatbuff only support one rrot at each IDL files, we had to seperate message schema to 2 files. -*/ -include "p2pmsg_content.fbs"; -namespace msg.fbuf.p2pmsg; - -table Container { //root type for message - version:uint16; - timestamp:uint64; - pubkey:[ubyte]; - lcl:[ubyte]; - last_primary_shard_id:Sequence_Hash; - signature:[ubyte]; // signature of the message content - content:[ubyte]; // message content: byte array of proposal,npl,etc -} - -root_type Container; \ No newline at end of file diff --git a/src/msg/fbuf/p2pmsg_container_generated.h b/src/msg/fbuf/p2pmsg_container_generated.h deleted file mode 100644 index 5df9ceb8..00000000 --- a/src/msg/fbuf/p2pmsg_container_generated.h +++ /dev/null @@ -1,208 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTAINER_MSG_FBUF_P2PMSG_H_ -#define FLATBUFFERS_GENERATED_P2PMSGCONTAINER_MSG_FBUF_P2PMSG_H_ - -#include "flatbuffers/flatbuffers.h" - -#include "common_schema_generated.h" -#include "p2pmsg_content_generated.h" - -namespace msg { -namespace fbuf { -namespace p2pmsg { - -struct Container; -struct ContainerBuilder; - -struct Container FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ContainerBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_VERSION = 4, - VT_TIMESTAMP = 6, - VT_PUBKEY = 8, - VT_LCL = 10, - VT_LAST_PRIMARY_SHARD_ID = 12, - VT_SIGNATURE = 14, - VT_CONTENT = 16 - }; - uint16_t version() const { - return GetField(VT_VERSION, 0); - } - bool mutate_version(uint16_t _version) { - return SetField(VT_VERSION, _version, 0); - } - uint64_t timestamp() const { - return GetField(VT_TIMESTAMP, 0); - } - bool mutate_timestamp(uint64_t _timestamp) { - return SetField(VT_TIMESTAMP, _timestamp, 0); - } - const flatbuffers::Vector *pubkey() const { - return GetPointer *>(VT_PUBKEY); - } - flatbuffers::Vector *mutable_pubkey() { - return GetPointer *>(VT_PUBKEY); - } - const flatbuffers::Vector *lcl() const { - return GetPointer *>(VT_LCL); - } - flatbuffers::Vector *mutable_lcl() { - return GetPointer *>(VT_LCL); - } - const msg::fbuf::p2pmsg::Sequence_Hash *last_primary_shard_id() const { - return GetPointer(VT_LAST_PRIMARY_SHARD_ID); - } - msg::fbuf::p2pmsg::Sequence_Hash *mutable_last_primary_shard_id() { - return GetPointer(VT_LAST_PRIMARY_SHARD_ID); - } - const flatbuffers::Vector *signature() const { - return GetPointer *>(VT_SIGNATURE); - } - flatbuffers::Vector *mutable_signature() { - return GetPointer *>(VT_SIGNATURE); - } - const flatbuffers::Vector *content() const { - return GetPointer *>(VT_CONTENT); - } - flatbuffers::Vector *mutable_content() { - return GetPointer *>(VT_CONTENT); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_VERSION) && - VerifyField(verifier, VT_TIMESTAMP) && - VerifyOffset(verifier, VT_PUBKEY) && - verifier.VerifyVector(pubkey()) && - VerifyOffset(verifier, VT_LCL) && - verifier.VerifyVector(lcl()) && - VerifyOffset(verifier, VT_LAST_PRIMARY_SHARD_ID) && - verifier.VerifyTable(last_primary_shard_id()) && - VerifyOffset(verifier, VT_SIGNATURE) && - verifier.VerifyVector(signature()) && - VerifyOffset(verifier, VT_CONTENT) && - verifier.VerifyVector(content()) && - verifier.EndTable(); - } -}; - -struct ContainerBuilder { - typedef Container Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_version(uint16_t version) { - fbb_.AddElement(Container::VT_VERSION, version, 0); - } - void add_timestamp(uint64_t timestamp) { - fbb_.AddElement(Container::VT_TIMESTAMP, timestamp, 0); - } - void add_pubkey(flatbuffers::Offset> pubkey) { - fbb_.AddOffset(Container::VT_PUBKEY, pubkey); - } - void add_lcl(flatbuffers::Offset> lcl) { - fbb_.AddOffset(Container::VT_LCL, lcl); - } - void add_last_primary_shard_id(flatbuffers::Offset last_primary_shard_id) { - fbb_.AddOffset(Container::VT_LAST_PRIMARY_SHARD_ID, last_primary_shard_id); - } - void add_signature(flatbuffers::Offset> signature) { - fbb_.AddOffset(Container::VT_SIGNATURE, signature); - } - void add_content(flatbuffers::Offset> content) { - fbb_.AddOffset(Container::VT_CONTENT, content); - } - explicit ContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateContainer( - flatbuffers::FlatBufferBuilder &_fbb, - uint16_t version = 0, - uint64_t timestamp = 0, - flatbuffers::Offset> pubkey = 0, - flatbuffers::Offset> lcl = 0, - flatbuffers::Offset last_primary_shard_id = 0, - flatbuffers::Offset> signature = 0, - flatbuffers::Offset> content = 0) { - ContainerBuilder builder_(_fbb); - builder_.add_timestamp(timestamp); - builder_.add_content(content); - builder_.add_signature(signature); - builder_.add_last_primary_shard_id(last_primary_shard_id); - builder_.add_lcl(lcl); - builder_.add_pubkey(pubkey); - builder_.add_version(version); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateContainerDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint16_t version = 0, - uint64_t timestamp = 0, - const std::vector *pubkey = nullptr, - const std::vector *lcl = nullptr, - flatbuffers::Offset last_primary_shard_id = 0, - const std::vector *signature = nullptr, - const std::vector *content = nullptr) { - auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; - auto lcl__ = lcl ? _fbb.CreateVector(*lcl) : 0; - auto signature__ = signature ? _fbb.CreateVector(*signature) : 0; - auto content__ = content ? _fbb.CreateVector(*content) : 0; - return msg::fbuf::p2pmsg::CreateContainer( - _fbb, - version, - timestamp, - pubkey__, - lcl__, - last_primary_shard_id, - signature__, - content__); -} - -inline const msg::fbuf::p2pmsg::Container *GetContainer(const void *buf) { - return flatbuffers::GetRoot(buf); -} - -inline const msg::fbuf::p2pmsg::Container *GetSizePrefixedContainer(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); -} - -inline Container *GetMutableContainer(void *buf) { - return flatbuffers::GetMutableRoot(buf); -} - -inline bool VerifyContainerBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); -} - -inline bool VerifySizePrefixedContainerBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); -} - -inline void FinishContainerBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedContainerBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.FinishSizePrefixed(root); -} - -} // namespace p2pmsg -} // namespace fbuf -} // namespace msg - -#endif // FLATBUFFERS_GENERATED_P2PMSGCONTAINER_MSG_FBUF_P2PMSG_H_ diff --git a/src/msg/fbuf/p2pmsg_content.fbs b/src/msg/fbuf/p2pmsg_content.fbs deleted file mode 100644 index 3f1412ad..00000000 --- a/src/msg/fbuf/p2pmsg_content.fbs +++ /dev/null @@ -1,141 +0,0 @@ -// IDL file for p2p message content schema. -// flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg_content.fbs - -include "common_schema.fbs"; -namespace msg.fbuf.p2pmsg; - -table Peer_Challenge_Message { - contract_id:string; - roundtime:uint32; - challenge:string; -} - -table Peer_Challenge_Response_Message { - challenge:string; - sig:[ubyte]; -} - -table UserInput { - input_container:[ubyte]; - signature:[ubyte]; - protocol:uint8; -} - -table UserInputGroup { - pubkey:[ubyte]; - messages:[UserInput]; -} - -union Message { - Peer_Challenge_Response_Message, - Peer_Challenge_Message, - NonUnl_Proposal_Message, - Proposal_Message, - Npl_Message, - Hpfs_Request_Message, - Hpfs_Response_Message, - Peer_Requirement_Announcement_Message, - Peer_List_Request_Message, - Peer_List_Response_Message, - Available_Capacity_Announcement_Message -} //message content type - -table Content { - message:Message; -} - -table NonUnl_Proposal_Message { - user_inputs:[UserInputGroup]; -} - -table Proposal_Message { //Proposal type message schema - stage:uint8; - time:uint64; - roundtime:uint32; - nonce: [ubyte]; - users:[ByteArray]; - input_hashes:[ByteArray]; - last_blob_shard_id: Sequence_Hash; - output_hash:[ubyte]; - output_sig:[ubyte]; - state_hash: [ubyte]; - patch_hash: [ubyte]; -} - -table Sequence_Hash { - shard_seq_no: uint64; - shard_hash: [ubyte]; -} - -table Npl_Message { //NPL type message schema - data:[ubyte]; -} - -enum Ledger_Response_Error : ubyte -{ - None = 0, - Invalid_Min_Ledger = 1, - Req_Ledger_Not_Found = 2 -} - -table Hpfs_Request_Message { //Hpfs request message schema - mount_id: uint32; - parent_path:string; - is_file:bool; - block_id:int32; - expected_hash:[ubyte]; -} - -union Hpfs_Response{ File_HashMap_Response, Block_Response, Fs_Entry_Response } - -table Hpfs_Response_Message{ - hpfs_response:Hpfs_Response; - hash:[ubyte]; - path: string; - mount_id: uint32; -} - -table Fs_Entry_Response{ - entries: [Hpfs_FS_Hash_Entry]; -} - -table File_HashMap_Response{ - file_length:uint64; - hash_map:[ubyte]; -} - -table Block_Response{ - block_id:uint32; - data: [ubyte]; -} - -table Hpfs_FS_Hash_Entry{ - name: string; - is_file: bool; - hash: [ubyte]; -} - -table Peer_Requirement_Announcement_Message{ - need_consensus_msg_forwarding: bool; -} - -table Available_Capacity_Announcement_Message{ - available_capacity:int16; - timestamp:uint64; -} - -table Peer_List_Request_Message{ -} - -table Peer_List_Response_Message{ - peer_list: [Peer_Properties]; -} - -table Peer_Properties { - host_address:string; - port:uint16; - available_capacity:int16; - timestamp:uint64; -} - -root_type Content; //root type for message content \ No newline at end of file diff --git a/src/msg/fbuf/p2pmsg_content_generated.h b/src/msg/fbuf/p2pmsg_content_generated.h deleted file mode 100644 index 328dade4..00000000 --- a/src/msg/fbuf/p2pmsg_content_generated.h +++ /dev/null @@ -1,2070 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - - -#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_ -#define FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_ - -#include "flatbuffers/flatbuffers.h" - -#include "common_schema_generated.h" - -namespace msg { -namespace fbuf { -namespace p2pmsg { - -struct Peer_Challenge_Message; -struct Peer_Challenge_MessageBuilder; - -struct Peer_Challenge_Response_Message; -struct Peer_Challenge_Response_MessageBuilder; - -struct UserInput; -struct UserInputBuilder; - -struct UserInputGroup; -struct UserInputGroupBuilder; - -struct Content; -struct ContentBuilder; - -struct NonUnl_Proposal_Message; -struct NonUnl_Proposal_MessageBuilder; - -struct Proposal_Message; -struct Proposal_MessageBuilder; - -struct Sequence_Hash; -struct Sequence_HashBuilder; - -struct Npl_Message; -struct Npl_MessageBuilder; - -struct Hpfs_Request_Message; -struct Hpfs_Request_MessageBuilder; - -struct Hpfs_Response_Message; -struct Hpfs_Response_MessageBuilder; - -struct Fs_Entry_Response; -struct Fs_Entry_ResponseBuilder; - -struct File_HashMap_Response; -struct File_HashMap_ResponseBuilder; - -struct Block_Response; -struct Block_ResponseBuilder; - -struct Hpfs_FS_Hash_Entry; -struct Hpfs_FS_Hash_EntryBuilder; - -struct Peer_Requirement_Announcement_Message; -struct Peer_Requirement_Announcement_MessageBuilder; - -struct Available_Capacity_Announcement_Message; -struct Available_Capacity_Announcement_MessageBuilder; - -struct Peer_List_Request_Message; -struct Peer_List_Request_MessageBuilder; - -struct Peer_List_Response_Message; -struct Peer_List_Response_MessageBuilder; - -struct Peer_Properties; -struct Peer_PropertiesBuilder; - -enum Message : uint8_t { - Message_NONE = 0, - Message_Peer_Challenge_Response_Message = 1, - Message_Peer_Challenge_Message = 2, - Message_NonUnl_Proposal_Message = 3, - Message_Proposal_Message = 4, - Message_Npl_Message = 5, - Message_Hpfs_Request_Message = 6, - Message_Hpfs_Response_Message = 7, - Message_Peer_Requirement_Announcement_Message = 8, - Message_Peer_List_Request_Message = 9, - Message_Peer_List_Response_Message = 10, - Message_Available_Capacity_Announcement_Message = 11, - Message_MIN = Message_NONE, - Message_MAX = Message_Available_Capacity_Announcement_Message -}; - -inline const Message (&EnumValuesMessage())[12] { - static const Message values[] = { - Message_NONE, - Message_Peer_Challenge_Response_Message, - Message_Peer_Challenge_Message, - Message_NonUnl_Proposal_Message, - Message_Proposal_Message, - Message_Npl_Message, - Message_Hpfs_Request_Message, - Message_Hpfs_Response_Message, - Message_Peer_Requirement_Announcement_Message, - Message_Peer_List_Request_Message, - Message_Peer_List_Response_Message, - Message_Available_Capacity_Announcement_Message - }; - return values; -} - -inline const char * const *EnumNamesMessage() { - static const char * const names[13] = { - "NONE", - "Peer_Challenge_Response_Message", - "Peer_Challenge_Message", - "NonUnl_Proposal_Message", - "Proposal_Message", - "Npl_Message", - "Hpfs_Request_Message", - "Hpfs_Response_Message", - "Peer_Requirement_Announcement_Message", - "Peer_List_Request_Message", - "Peer_List_Response_Message", - "Available_Capacity_Announcement_Message", - nullptr - }; - return names; -} - -inline const char *EnumNameMessage(Message e) { - if (flatbuffers::IsOutRange(e, Message_NONE, Message_Available_Capacity_Announcement_Message)) return ""; - const size_t index = static_cast(e); - return EnumNamesMessage()[index]; -} - -template struct MessageTraits { - static const Message enum_value = Message_NONE; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Peer_Challenge_Response_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Peer_Challenge_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_NonUnl_Proposal_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Proposal_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Npl_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Hpfs_Request_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Hpfs_Response_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Peer_Requirement_Announcement_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Peer_List_Request_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Peer_List_Response_Message; -}; - -template<> struct MessageTraits { - static const Message enum_value = Message_Available_Capacity_Announcement_Message; -}; - -bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type); -bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); - -enum Ledger_Response_Error : uint8_t { - Ledger_Response_Error_None = 0, - Ledger_Response_Error_Invalid_Min_Ledger = 1, - Ledger_Response_Error_Req_Ledger_Not_Found = 2, - Ledger_Response_Error_MIN = Ledger_Response_Error_None, - Ledger_Response_Error_MAX = Ledger_Response_Error_Req_Ledger_Not_Found -}; - -inline const Ledger_Response_Error (&EnumValuesLedger_Response_Error())[3] { - static const Ledger_Response_Error values[] = { - Ledger_Response_Error_None, - Ledger_Response_Error_Invalid_Min_Ledger, - Ledger_Response_Error_Req_Ledger_Not_Found - }; - return values; -} - -inline const char * const *EnumNamesLedger_Response_Error() { - static const char * const names[4] = { - "None", - "Invalid_Min_Ledger", - "Req_Ledger_Not_Found", - nullptr - }; - return names; -} - -inline const char *EnumNameLedger_Response_Error(Ledger_Response_Error e) { - if (flatbuffers::IsOutRange(e, Ledger_Response_Error_None, Ledger_Response_Error_Req_Ledger_Not_Found)) return ""; - const size_t index = static_cast(e); - return EnumNamesLedger_Response_Error()[index]; -} - -enum Hpfs_Response : uint8_t { - Hpfs_Response_NONE = 0, - Hpfs_Response_File_HashMap_Response = 1, - Hpfs_Response_Block_Response = 2, - Hpfs_Response_Fs_Entry_Response = 3, - Hpfs_Response_MIN = Hpfs_Response_NONE, - Hpfs_Response_MAX = Hpfs_Response_Fs_Entry_Response -}; - -inline const Hpfs_Response (&EnumValuesHpfs_Response())[4] { - static const Hpfs_Response values[] = { - Hpfs_Response_NONE, - Hpfs_Response_File_HashMap_Response, - Hpfs_Response_Block_Response, - Hpfs_Response_Fs_Entry_Response - }; - return values; -} - -inline const char * const *EnumNamesHpfs_Response() { - static const char * const names[5] = { - "NONE", - "File_HashMap_Response", - "Block_Response", - "Fs_Entry_Response", - nullptr - }; - return names; -} - -inline const char *EnumNameHpfs_Response(Hpfs_Response e) { - if (flatbuffers::IsOutRange(e, Hpfs_Response_NONE, Hpfs_Response_Fs_Entry_Response)) return ""; - const size_t index = static_cast(e); - return EnumNamesHpfs_Response()[index]; -} - -template struct Hpfs_ResponseTraits { - static const Hpfs_Response enum_value = Hpfs_Response_NONE; -}; - -template<> struct Hpfs_ResponseTraits { - static const Hpfs_Response enum_value = Hpfs_Response_File_HashMap_Response; -}; - -template<> struct Hpfs_ResponseTraits { - static const Hpfs_Response enum_value = Hpfs_Response_Block_Response; -}; - -template<> struct Hpfs_ResponseTraits { - static const Hpfs_Response enum_value = Hpfs_Response_Fs_Entry_Response; -}; - -bool VerifyHpfs_Response(flatbuffers::Verifier &verifier, const void *obj, Hpfs_Response type); -bool VerifyHpfs_ResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); - -struct Peer_Challenge_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_Challenge_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CONTRACT_ID = 4, - VT_ROUNDTIME = 6, - VT_CHALLENGE = 8 - }; - const flatbuffers::String *contract_id() const { - return GetPointer(VT_CONTRACT_ID); - } - flatbuffers::String *mutable_contract_id() { - return GetPointer(VT_CONTRACT_ID); - } - uint32_t roundtime() const { - return GetField(VT_ROUNDTIME, 0); - } - bool mutate_roundtime(uint32_t _roundtime) { - return SetField(VT_ROUNDTIME, _roundtime, 0); - } - const flatbuffers::String *challenge() const { - return GetPointer(VT_CHALLENGE); - } - flatbuffers::String *mutable_challenge() { - return GetPointer(VT_CHALLENGE); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_CONTRACT_ID) && - verifier.VerifyString(contract_id()) && - VerifyField(verifier, VT_ROUNDTIME) && - VerifyOffset(verifier, VT_CHALLENGE) && - verifier.VerifyString(challenge()) && - verifier.EndTable(); - } -}; - -struct Peer_Challenge_MessageBuilder { - typedef Peer_Challenge_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_contract_id(flatbuffers::Offset contract_id) { - fbb_.AddOffset(Peer_Challenge_Message::VT_CONTRACT_ID, contract_id); - } - void add_roundtime(uint32_t roundtime) { - fbb_.AddElement(Peer_Challenge_Message::VT_ROUNDTIME, roundtime, 0); - } - void add_challenge(flatbuffers::Offset challenge) { - fbb_.AddOffset(Peer_Challenge_Message::VT_CHALLENGE, challenge); - } - explicit Peer_Challenge_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_Challenge_Message( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset contract_id = 0, - uint32_t roundtime = 0, - flatbuffers::Offset challenge = 0) { - Peer_Challenge_MessageBuilder builder_(_fbb); - builder_.add_challenge(challenge); - builder_.add_roundtime(roundtime); - builder_.add_contract_id(contract_id); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreatePeer_Challenge_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *contract_id = nullptr, - uint32_t roundtime = 0, - const char *challenge = nullptr) { - auto contract_id__ = contract_id ? _fbb.CreateString(contract_id) : 0; - auto challenge__ = challenge ? _fbb.CreateString(challenge) : 0; - return msg::fbuf::p2pmsg::CreatePeer_Challenge_Message( - _fbb, - contract_id__, - roundtime, - challenge__); -} - -struct Peer_Challenge_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_Challenge_Response_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CHALLENGE = 4, - VT_SIG = 6 - }; - const flatbuffers::String *challenge() const { - return GetPointer(VT_CHALLENGE); - } - flatbuffers::String *mutable_challenge() { - return GetPointer(VT_CHALLENGE); - } - const flatbuffers::Vector *sig() const { - return GetPointer *>(VT_SIG); - } - flatbuffers::Vector *mutable_sig() { - return GetPointer *>(VT_SIG); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_CHALLENGE) && - verifier.VerifyString(challenge()) && - VerifyOffset(verifier, VT_SIG) && - verifier.VerifyVector(sig()) && - verifier.EndTable(); - } -}; - -struct Peer_Challenge_Response_MessageBuilder { - typedef Peer_Challenge_Response_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_challenge(flatbuffers::Offset challenge) { - fbb_.AddOffset(Peer_Challenge_Response_Message::VT_CHALLENGE, challenge); - } - void add_sig(flatbuffers::Offset> sig) { - fbb_.AddOffset(Peer_Challenge_Response_Message::VT_SIG, sig); - } - explicit Peer_Challenge_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_Challenge_Response_Message( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset challenge = 0, - flatbuffers::Offset> sig = 0) { - Peer_Challenge_Response_MessageBuilder builder_(_fbb); - builder_.add_sig(sig); - builder_.add_challenge(challenge); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreatePeer_Challenge_Response_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *challenge = nullptr, - const std::vector *sig = nullptr) { - auto challenge__ = challenge ? _fbb.CreateString(challenge) : 0; - auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; - return msg::fbuf::p2pmsg::CreatePeer_Challenge_Response_Message( - _fbb, - challenge__, - sig__); -} - -struct UserInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UserInputBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_INPUT_CONTAINER = 4, - VT_SIGNATURE = 6, - VT_PROTOCOL = 8 - }; - const flatbuffers::Vector *input_container() const { - return GetPointer *>(VT_INPUT_CONTAINER); - } - flatbuffers::Vector *mutable_input_container() { - return GetPointer *>(VT_INPUT_CONTAINER); - } - const flatbuffers::Vector *signature() const { - return GetPointer *>(VT_SIGNATURE); - } - flatbuffers::Vector *mutable_signature() { - return GetPointer *>(VT_SIGNATURE); - } - uint8_t protocol() const { - return GetField(VT_PROTOCOL, 0); - } - bool mutate_protocol(uint8_t _protocol) { - return SetField(VT_PROTOCOL, _protocol, 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_INPUT_CONTAINER) && - verifier.VerifyVector(input_container()) && - VerifyOffset(verifier, VT_SIGNATURE) && - verifier.VerifyVector(signature()) && - VerifyField(verifier, VT_PROTOCOL) && - verifier.EndTable(); - } -}; - -struct UserInputBuilder { - typedef UserInput Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_input_container(flatbuffers::Offset> input_container) { - fbb_.AddOffset(UserInput::VT_INPUT_CONTAINER, input_container); - } - void add_signature(flatbuffers::Offset> signature) { - fbb_.AddOffset(UserInput::VT_SIGNATURE, signature); - } - void add_protocol(uint8_t protocol) { - fbb_.AddElement(UserInput::VT_PROTOCOL, protocol, 0); - } - explicit UserInputBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateUserInput( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> input_container = 0, - flatbuffers::Offset> signature = 0, - uint8_t protocol = 0) { - UserInputBuilder builder_(_fbb); - builder_.add_signature(signature); - builder_.add_input_container(input_container); - builder_.add_protocol(protocol); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateUserInputDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *input_container = nullptr, - const std::vector *signature = nullptr, - uint8_t protocol = 0) { - auto input_container__ = input_container ? _fbb.CreateVector(*input_container) : 0; - auto signature__ = signature ? _fbb.CreateVector(*signature) : 0; - return msg::fbuf::p2pmsg::CreateUserInput( - _fbb, - input_container__, - signature__, - protocol); -} - -struct UserInputGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UserInputGroupBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PUBKEY = 4, - VT_MESSAGES = 6 - }; - const flatbuffers::Vector *pubkey() const { - return GetPointer *>(VT_PUBKEY); - } - flatbuffers::Vector *mutable_pubkey() { - return GetPointer *>(VT_PUBKEY); - } - const flatbuffers::Vector> *messages() const { - return GetPointer> *>(VT_MESSAGES); - } - flatbuffers::Vector> *mutable_messages() { - return GetPointer> *>(VT_MESSAGES); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_PUBKEY) && - verifier.VerifyVector(pubkey()) && - VerifyOffset(verifier, VT_MESSAGES) && - verifier.VerifyVector(messages()) && - verifier.VerifyVectorOfTables(messages()) && - verifier.EndTable(); - } -}; - -struct UserInputGroupBuilder { - typedef UserInputGroup Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_pubkey(flatbuffers::Offset> pubkey) { - fbb_.AddOffset(UserInputGroup::VT_PUBKEY, pubkey); - } - void add_messages(flatbuffers::Offset>> messages) { - fbb_.AddOffset(UserInputGroup::VT_MESSAGES, messages); - } - explicit UserInputGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateUserInputGroup( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> pubkey = 0, - flatbuffers::Offset>> messages = 0) { - UserInputGroupBuilder builder_(_fbb); - builder_.add_messages(messages); - builder_.add_pubkey(pubkey); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateUserInputGroupDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *pubkey = nullptr, - const std::vector> *messages = nullptr) { - auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; - auto messages__ = messages ? _fbb.CreateVector>(*messages) : 0; - return msg::fbuf::p2pmsg::CreateUserInputGroup( - _fbb, - pubkey__, - messages__); -} - -struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ContentBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MESSAGE_TYPE = 4, - VT_MESSAGE = 6 - }; - msg::fbuf::p2pmsg::Message message_type() const { - return static_cast(GetField(VT_MESSAGE_TYPE, 0)); - } - const void *message() const { - return GetPointer(VT_MESSAGE); - } - template const T *message_as() const; - const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *message_as_Peer_Challenge_Response_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Peer_Challenge_Response_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Peer_Challenge_Message *message_as_Peer_Challenge_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Peer_Challenge_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *message_as_NonUnl_Proposal_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_NonUnl_Proposal_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Proposal_Message *message_as_Proposal_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Proposal_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Npl_Message *message_as_Npl_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Npl_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Hpfs_Request_Message *message_as_Hpfs_Request_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Hpfs_Request_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Hpfs_Response_Message *message_as_Hpfs_Response_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Hpfs_Response_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *message_as_Peer_Requirement_Announcement_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Peer_Requirement_Announcement_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Peer_List_Request_Message *message_as_Peer_List_Request_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Peer_List_Request_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Peer_List_Response_Message *message_as_Peer_List_Response_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Peer_List_Response_Message ? static_cast(message()) : nullptr; - } - const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *message_as_Available_Capacity_Announcement_Message() const { - return message_type() == msg::fbuf::p2pmsg::Message_Available_Capacity_Announcement_Message ? static_cast(message()) : nullptr; - } - void *mutable_message() { - return GetPointer(VT_MESSAGE); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_MESSAGE_TYPE) && - VerifyOffset(verifier, VT_MESSAGE) && - VerifyMessage(verifier, message(), message_type()) && - verifier.EndTable(); - } -}; - -template<> inline const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *Content::message_as() const { - return message_as_Peer_Challenge_Response_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Peer_Challenge_Message *Content::message_as() const { - return message_as_Peer_Challenge_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *Content::message_as() const { - return message_as_NonUnl_Proposal_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Proposal_Message *Content::message_as() const { - return message_as_Proposal_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Npl_Message *Content::message_as() const { - return message_as_Npl_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Hpfs_Request_Message *Content::message_as() const { - return message_as_Hpfs_Request_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Hpfs_Response_Message *Content::message_as() const { - return message_as_Hpfs_Response_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *Content::message_as() const { - return message_as_Peer_Requirement_Announcement_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Peer_List_Request_Message *Content::message_as() const { - return message_as_Peer_List_Request_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Peer_List_Response_Message *Content::message_as() const { - return message_as_Peer_List_Response_Message(); -} - -template<> inline const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *Content::message_as() const { - return message_as_Available_Capacity_Announcement_Message(); -} - -struct ContentBuilder { - typedef Content Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_message_type(msg::fbuf::p2pmsg::Message message_type) { - fbb_.AddElement(Content::VT_MESSAGE_TYPE, static_cast(message_type), 0); - } - void add_message(flatbuffers::Offset message) { - fbb_.AddOffset(Content::VT_MESSAGE, message); - } - explicit ContentBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateContent( - flatbuffers::FlatBufferBuilder &_fbb, - msg::fbuf::p2pmsg::Message message_type = msg::fbuf::p2pmsg::Message_NONE, - flatbuffers::Offset message = 0) { - ContentBuilder builder_(_fbb); - builder_.add_message(message); - builder_.add_message_type(message_type); - return builder_.Finish(); -} - -struct NonUnl_Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef NonUnl_Proposal_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_USER_INPUTS = 4 - }; - const flatbuffers::Vector> *user_inputs() const { - return GetPointer> *>(VT_USER_INPUTS); - } - flatbuffers::Vector> *mutable_user_inputs() { - return GetPointer> *>(VT_USER_INPUTS); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_USER_INPUTS) && - verifier.VerifyVector(user_inputs()) && - verifier.VerifyVectorOfTables(user_inputs()) && - verifier.EndTable(); - } -}; - -struct NonUnl_Proposal_MessageBuilder { - typedef NonUnl_Proposal_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_user_inputs(flatbuffers::Offset>> user_inputs) { - fbb_.AddOffset(NonUnl_Proposal_Message::VT_USER_INPUTS, user_inputs); - } - explicit NonUnl_Proposal_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateNonUnl_Proposal_Message( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> user_inputs = 0) { - NonUnl_Proposal_MessageBuilder builder_(_fbb); - builder_.add_user_inputs(user_inputs); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateNonUnl_Proposal_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *user_inputs = nullptr) { - auto user_inputs__ = user_inputs ? _fbb.CreateVector>(*user_inputs) : 0; - return msg::fbuf::p2pmsg::CreateNonUnl_Proposal_Message( - _fbb, - user_inputs__); -} - -struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Proposal_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STAGE = 4, - VT_TIME = 6, - VT_ROUNDTIME = 8, - VT_NONCE = 10, - VT_USERS = 12, - VT_INPUT_HASHES = 14, - VT_LAST_BLOB_SHARD_ID = 16, - VT_OUTPUT_HASH = 18, - VT_OUTPUT_SIG = 20, - VT_STATE_HASH = 22, - VT_PATCH_HASH = 24 - }; - uint8_t stage() const { - return GetField(VT_STAGE, 0); - } - bool mutate_stage(uint8_t _stage) { - return SetField(VT_STAGE, _stage, 0); - } - uint64_t time() const { - return GetField(VT_TIME, 0); - } - bool mutate_time(uint64_t _time) { - return SetField(VT_TIME, _time, 0); - } - uint32_t roundtime() const { - return GetField(VT_ROUNDTIME, 0); - } - bool mutate_roundtime(uint32_t _roundtime) { - return SetField(VT_ROUNDTIME, _roundtime, 0); - } - const flatbuffers::Vector *nonce() const { - return GetPointer *>(VT_NONCE); - } - flatbuffers::Vector *mutable_nonce() { - return GetPointer *>(VT_NONCE); - } - const flatbuffers::Vector> *users() const { - return GetPointer> *>(VT_USERS); - } - flatbuffers::Vector> *mutable_users() { - return GetPointer> *>(VT_USERS); - } - const flatbuffers::Vector> *input_hashes() const { - return GetPointer> *>(VT_INPUT_HASHES); - } - flatbuffers::Vector> *mutable_input_hashes() { - return GetPointer> *>(VT_INPUT_HASHES); - } - const msg::fbuf::p2pmsg::Sequence_Hash *last_blob_shard_id() const { - return GetPointer(VT_LAST_BLOB_SHARD_ID); - } - msg::fbuf::p2pmsg::Sequence_Hash *mutable_last_blob_shard_id() { - return GetPointer(VT_LAST_BLOB_SHARD_ID); - } - const flatbuffers::Vector *output_hash() const { - return GetPointer *>(VT_OUTPUT_HASH); - } - flatbuffers::Vector *mutable_output_hash() { - return GetPointer *>(VT_OUTPUT_HASH); - } - const flatbuffers::Vector *output_sig() const { - return GetPointer *>(VT_OUTPUT_SIG); - } - flatbuffers::Vector *mutable_output_sig() { - return GetPointer *>(VT_OUTPUT_SIG); - } - const flatbuffers::Vector *state_hash() const { - return GetPointer *>(VT_STATE_HASH); - } - flatbuffers::Vector *mutable_state_hash() { - return GetPointer *>(VT_STATE_HASH); - } - const flatbuffers::Vector *patch_hash() const { - return GetPointer *>(VT_PATCH_HASH); - } - flatbuffers::Vector *mutable_patch_hash() { - return GetPointer *>(VT_PATCH_HASH); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_STAGE) && - VerifyField(verifier, VT_TIME) && - VerifyField(verifier, VT_ROUNDTIME) && - VerifyOffset(verifier, VT_NONCE) && - verifier.VerifyVector(nonce()) && - VerifyOffset(verifier, VT_USERS) && - verifier.VerifyVector(users()) && - verifier.VerifyVectorOfTables(users()) && - VerifyOffset(verifier, VT_INPUT_HASHES) && - verifier.VerifyVector(input_hashes()) && - verifier.VerifyVectorOfTables(input_hashes()) && - VerifyOffset(verifier, VT_LAST_BLOB_SHARD_ID) && - verifier.VerifyTable(last_blob_shard_id()) && - VerifyOffset(verifier, VT_OUTPUT_HASH) && - verifier.VerifyVector(output_hash()) && - VerifyOffset(verifier, VT_OUTPUT_SIG) && - verifier.VerifyVector(output_sig()) && - VerifyOffset(verifier, VT_STATE_HASH) && - verifier.VerifyVector(state_hash()) && - VerifyOffset(verifier, VT_PATCH_HASH) && - verifier.VerifyVector(patch_hash()) && - verifier.EndTable(); - } -}; - -struct Proposal_MessageBuilder { - typedef Proposal_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_stage(uint8_t stage) { - fbb_.AddElement(Proposal_Message::VT_STAGE, stage, 0); - } - void add_time(uint64_t time) { - fbb_.AddElement(Proposal_Message::VT_TIME, time, 0); - } - void add_roundtime(uint32_t roundtime) { - fbb_.AddElement(Proposal_Message::VT_ROUNDTIME, roundtime, 0); - } - void add_nonce(flatbuffers::Offset> nonce) { - fbb_.AddOffset(Proposal_Message::VT_NONCE, nonce); - } - void add_users(flatbuffers::Offset>> users) { - fbb_.AddOffset(Proposal_Message::VT_USERS, users); - } - void add_input_hashes(flatbuffers::Offset>> input_hashes) { - fbb_.AddOffset(Proposal_Message::VT_INPUT_HASHES, input_hashes); - } - void add_last_blob_shard_id(flatbuffers::Offset last_blob_shard_id) { - fbb_.AddOffset(Proposal_Message::VT_LAST_BLOB_SHARD_ID, last_blob_shard_id); - } - void add_output_hash(flatbuffers::Offset> output_hash) { - fbb_.AddOffset(Proposal_Message::VT_OUTPUT_HASH, output_hash); - } - void add_output_sig(flatbuffers::Offset> output_sig) { - fbb_.AddOffset(Proposal_Message::VT_OUTPUT_SIG, output_sig); - } - void add_state_hash(flatbuffers::Offset> state_hash) { - fbb_.AddOffset(Proposal_Message::VT_STATE_HASH, state_hash); - } - void add_patch_hash(flatbuffers::Offset> patch_hash) { - fbb_.AddOffset(Proposal_Message::VT_PATCH_HASH, patch_hash); - } - explicit Proposal_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateProposal_Message( - flatbuffers::FlatBufferBuilder &_fbb, - uint8_t stage = 0, - uint64_t time = 0, - uint32_t roundtime = 0, - flatbuffers::Offset> nonce = 0, - flatbuffers::Offset>> users = 0, - flatbuffers::Offset>> input_hashes = 0, - flatbuffers::Offset last_blob_shard_id = 0, - flatbuffers::Offset> output_hash = 0, - flatbuffers::Offset> output_sig = 0, - flatbuffers::Offset> state_hash = 0, - flatbuffers::Offset> patch_hash = 0) { - Proposal_MessageBuilder builder_(_fbb); - builder_.add_time(time); - builder_.add_patch_hash(patch_hash); - builder_.add_state_hash(state_hash); - builder_.add_output_sig(output_sig); - builder_.add_output_hash(output_hash); - builder_.add_last_blob_shard_id(last_blob_shard_id); - builder_.add_input_hashes(input_hashes); - builder_.add_users(users); - builder_.add_nonce(nonce); - builder_.add_roundtime(roundtime); - builder_.add_stage(stage); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateProposal_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint8_t stage = 0, - uint64_t time = 0, - uint32_t roundtime = 0, - const std::vector *nonce = nullptr, - const std::vector> *users = nullptr, - const std::vector> *input_hashes = nullptr, - flatbuffers::Offset last_blob_shard_id = 0, - const std::vector *output_hash = nullptr, - const std::vector *output_sig = nullptr, - const std::vector *state_hash = nullptr, - const std::vector *patch_hash = nullptr) { - auto nonce__ = nonce ? _fbb.CreateVector(*nonce) : 0; - auto users__ = users ? _fbb.CreateVector>(*users) : 0; - auto input_hashes__ = input_hashes ? _fbb.CreateVector>(*input_hashes) : 0; - auto output_hash__ = output_hash ? _fbb.CreateVector(*output_hash) : 0; - auto output_sig__ = output_sig ? _fbb.CreateVector(*output_sig) : 0; - auto state_hash__ = state_hash ? _fbb.CreateVector(*state_hash) : 0; - auto patch_hash__ = patch_hash ? _fbb.CreateVector(*patch_hash) : 0; - return msg::fbuf::p2pmsg::CreateProposal_Message( - _fbb, - stage, - time, - roundtime, - nonce__, - users__, - input_hashes__, - last_blob_shard_id, - output_hash__, - output_sig__, - state_hash__, - patch_hash__); -} - -struct Sequence_Hash FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Sequence_HashBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SHARD_SEQ_NO = 4, - VT_SHARD_HASH = 6 - }; - uint64_t shard_seq_no() const { - return GetField(VT_SHARD_SEQ_NO, 0); - } - bool mutate_shard_seq_no(uint64_t _shard_seq_no) { - return SetField(VT_SHARD_SEQ_NO, _shard_seq_no, 0); - } - const flatbuffers::Vector *shard_hash() const { - return GetPointer *>(VT_SHARD_HASH); - } - flatbuffers::Vector *mutable_shard_hash() { - return GetPointer *>(VT_SHARD_HASH); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_SHARD_SEQ_NO) && - VerifyOffset(verifier, VT_SHARD_HASH) && - verifier.VerifyVector(shard_hash()) && - verifier.EndTable(); - } -}; - -struct Sequence_HashBuilder { - typedef Sequence_Hash Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_shard_seq_no(uint64_t shard_seq_no) { - fbb_.AddElement(Sequence_Hash::VT_SHARD_SEQ_NO, shard_seq_no, 0); - } - void add_shard_hash(flatbuffers::Offset> shard_hash) { - fbb_.AddOffset(Sequence_Hash::VT_SHARD_HASH, shard_hash); - } - explicit Sequence_HashBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateSequence_Hash( - flatbuffers::FlatBufferBuilder &_fbb, - uint64_t shard_seq_no = 0, - flatbuffers::Offset> shard_hash = 0) { - Sequence_HashBuilder builder_(_fbb); - builder_.add_shard_seq_no(shard_seq_no); - builder_.add_shard_hash(shard_hash); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateSequence_HashDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint64_t shard_seq_no = 0, - const std::vector *shard_hash = nullptr) { - auto shard_hash__ = shard_hash ? _fbb.CreateVector(*shard_hash) : 0; - return msg::fbuf::p2pmsg::CreateSequence_Hash( - _fbb, - shard_seq_no, - shard_hash__); -} - -struct Npl_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Npl_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DATA = 4 - }; - const flatbuffers::Vector *data() const { - return GetPointer *>(VT_DATA); - } - flatbuffers::Vector *mutable_data() { - return GetPointer *>(VT_DATA); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_DATA) && - verifier.VerifyVector(data()) && - verifier.EndTable(); - } -}; - -struct Npl_MessageBuilder { - typedef Npl_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_data(flatbuffers::Offset> data) { - fbb_.AddOffset(Npl_Message::VT_DATA, data); - } - explicit Npl_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateNpl_Message( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> data = 0) { - Npl_MessageBuilder builder_(_fbb); - builder_.add_data(data); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateNpl_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *data = nullptr) { - auto data__ = data ? _fbb.CreateVector(*data) : 0; - return msg::fbuf::p2pmsg::CreateNpl_Message( - _fbb, - data__); -} - -struct Hpfs_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Hpfs_Request_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MOUNT_ID = 4, - VT_PARENT_PATH = 6, - VT_IS_FILE = 8, - VT_BLOCK_ID = 10, - VT_EXPECTED_HASH = 12 - }; - uint32_t mount_id() const { - return GetField(VT_MOUNT_ID, 0); - } - bool mutate_mount_id(uint32_t _mount_id) { - return SetField(VT_MOUNT_ID, _mount_id, 0); - } - const flatbuffers::String *parent_path() const { - return GetPointer(VT_PARENT_PATH); - } - flatbuffers::String *mutable_parent_path() { - return GetPointer(VT_PARENT_PATH); - } - bool is_file() const { - return GetField(VT_IS_FILE, 0) != 0; - } - bool mutate_is_file(bool _is_file) { - return SetField(VT_IS_FILE, static_cast(_is_file), 0); - } - int32_t block_id() const { - return GetField(VT_BLOCK_ID, 0); - } - bool mutate_block_id(int32_t _block_id) { - return SetField(VT_BLOCK_ID, _block_id, 0); - } - const flatbuffers::Vector *expected_hash() const { - return GetPointer *>(VT_EXPECTED_HASH); - } - flatbuffers::Vector *mutable_expected_hash() { - return GetPointer *>(VT_EXPECTED_HASH); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_MOUNT_ID) && - VerifyOffset(verifier, VT_PARENT_PATH) && - verifier.VerifyString(parent_path()) && - VerifyField(verifier, VT_IS_FILE) && - VerifyField(verifier, VT_BLOCK_ID) && - VerifyOffset(verifier, VT_EXPECTED_HASH) && - verifier.VerifyVector(expected_hash()) && - verifier.EndTable(); - } -}; - -struct Hpfs_Request_MessageBuilder { - typedef Hpfs_Request_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_mount_id(uint32_t mount_id) { - fbb_.AddElement(Hpfs_Request_Message::VT_MOUNT_ID, mount_id, 0); - } - void add_parent_path(flatbuffers::Offset parent_path) { - fbb_.AddOffset(Hpfs_Request_Message::VT_PARENT_PATH, parent_path); - } - void add_is_file(bool is_file) { - fbb_.AddElement(Hpfs_Request_Message::VT_IS_FILE, static_cast(is_file), 0); - } - void add_block_id(int32_t block_id) { - fbb_.AddElement(Hpfs_Request_Message::VT_BLOCK_ID, block_id, 0); - } - void add_expected_hash(flatbuffers::Offset> expected_hash) { - fbb_.AddOffset(Hpfs_Request_Message::VT_EXPECTED_HASH, expected_hash); - } - explicit Hpfs_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateHpfs_Request_Message( - flatbuffers::FlatBufferBuilder &_fbb, - uint32_t mount_id = 0, - flatbuffers::Offset parent_path = 0, - bool is_file = false, - int32_t block_id = 0, - flatbuffers::Offset> expected_hash = 0) { - Hpfs_Request_MessageBuilder builder_(_fbb); - builder_.add_expected_hash(expected_hash); - builder_.add_block_id(block_id); - builder_.add_parent_path(parent_path); - builder_.add_mount_id(mount_id); - builder_.add_is_file(is_file); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateHpfs_Request_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint32_t mount_id = 0, - const char *parent_path = nullptr, - bool is_file = false, - int32_t block_id = 0, - const std::vector *expected_hash = nullptr) { - auto parent_path__ = parent_path ? _fbb.CreateString(parent_path) : 0; - auto expected_hash__ = expected_hash ? _fbb.CreateVector(*expected_hash) : 0; - return msg::fbuf::p2pmsg::CreateHpfs_Request_Message( - _fbb, - mount_id, - parent_path__, - is_file, - block_id, - expected_hash__); -} - -struct Hpfs_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Hpfs_Response_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_HPFS_RESPONSE_TYPE = 4, - VT_HPFS_RESPONSE = 6, - VT_HASH = 8, - VT_PATH = 10, - VT_MOUNT_ID = 12 - }; - msg::fbuf::p2pmsg::Hpfs_Response hpfs_response_type() const { - return static_cast(GetField(VT_HPFS_RESPONSE_TYPE, 0)); - } - const void *hpfs_response() const { - return GetPointer(VT_HPFS_RESPONSE); - } - template const T *hpfs_response_as() const; - const msg::fbuf::p2pmsg::File_HashMap_Response *hpfs_response_as_File_HashMap_Response() const { - return hpfs_response_type() == msg::fbuf::p2pmsg::Hpfs_Response_File_HashMap_Response ? static_cast(hpfs_response()) : nullptr; - } - const msg::fbuf::p2pmsg::Block_Response *hpfs_response_as_Block_Response() const { - return hpfs_response_type() == msg::fbuf::p2pmsg::Hpfs_Response_Block_Response ? static_cast(hpfs_response()) : nullptr; - } - const msg::fbuf::p2pmsg::Fs_Entry_Response *hpfs_response_as_Fs_Entry_Response() const { - return hpfs_response_type() == msg::fbuf::p2pmsg::Hpfs_Response_Fs_Entry_Response ? static_cast(hpfs_response()) : nullptr; - } - void *mutable_hpfs_response() { - return GetPointer(VT_HPFS_RESPONSE); - } - const flatbuffers::Vector *hash() const { - return GetPointer *>(VT_HASH); - } - flatbuffers::Vector *mutable_hash() { - return GetPointer *>(VT_HASH); - } - const flatbuffers::String *path() const { - return GetPointer(VT_PATH); - } - flatbuffers::String *mutable_path() { - return GetPointer(VT_PATH); - } - uint32_t mount_id() const { - return GetField(VT_MOUNT_ID, 0); - } - bool mutate_mount_id(uint32_t _mount_id) { - return SetField(VT_MOUNT_ID, _mount_id, 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_HPFS_RESPONSE_TYPE) && - VerifyOffset(verifier, VT_HPFS_RESPONSE) && - VerifyHpfs_Response(verifier, hpfs_response(), hpfs_response_type()) && - VerifyOffset(verifier, VT_HASH) && - verifier.VerifyVector(hash()) && - VerifyOffset(verifier, VT_PATH) && - verifier.VerifyString(path()) && - VerifyField(verifier, VT_MOUNT_ID) && - verifier.EndTable(); - } -}; - -template<> inline const msg::fbuf::p2pmsg::File_HashMap_Response *Hpfs_Response_Message::hpfs_response_as() const { - return hpfs_response_as_File_HashMap_Response(); -} - -template<> inline const msg::fbuf::p2pmsg::Block_Response *Hpfs_Response_Message::hpfs_response_as() const { - return hpfs_response_as_Block_Response(); -} - -template<> inline const msg::fbuf::p2pmsg::Fs_Entry_Response *Hpfs_Response_Message::hpfs_response_as() const { - return hpfs_response_as_Fs_Entry_Response(); -} - -struct Hpfs_Response_MessageBuilder { - typedef Hpfs_Response_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_hpfs_response_type(msg::fbuf::p2pmsg::Hpfs_Response hpfs_response_type) { - fbb_.AddElement(Hpfs_Response_Message::VT_HPFS_RESPONSE_TYPE, static_cast(hpfs_response_type), 0); - } - void add_hpfs_response(flatbuffers::Offset hpfs_response) { - fbb_.AddOffset(Hpfs_Response_Message::VT_HPFS_RESPONSE, hpfs_response); - } - void add_hash(flatbuffers::Offset> hash) { - fbb_.AddOffset(Hpfs_Response_Message::VT_HASH, hash); - } - void add_path(flatbuffers::Offset path) { - fbb_.AddOffset(Hpfs_Response_Message::VT_PATH, path); - } - void add_mount_id(uint32_t mount_id) { - fbb_.AddElement(Hpfs_Response_Message::VT_MOUNT_ID, mount_id, 0); - } - explicit Hpfs_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateHpfs_Response_Message( - flatbuffers::FlatBufferBuilder &_fbb, - msg::fbuf::p2pmsg::Hpfs_Response hpfs_response_type = msg::fbuf::p2pmsg::Hpfs_Response_NONE, - flatbuffers::Offset hpfs_response = 0, - flatbuffers::Offset> hash = 0, - flatbuffers::Offset path = 0, - uint32_t mount_id = 0) { - Hpfs_Response_MessageBuilder builder_(_fbb); - builder_.add_mount_id(mount_id); - builder_.add_path(path); - builder_.add_hash(hash); - builder_.add_hpfs_response(hpfs_response); - builder_.add_hpfs_response_type(hpfs_response_type); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateHpfs_Response_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - msg::fbuf::p2pmsg::Hpfs_Response hpfs_response_type = msg::fbuf::p2pmsg::Hpfs_Response_NONE, - flatbuffers::Offset hpfs_response = 0, - const std::vector *hash = nullptr, - const char *path = nullptr, - uint32_t mount_id = 0) { - auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; - auto path__ = path ? _fbb.CreateString(path) : 0; - return msg::fbuf::p2pmsg::CreateHpfs_Response_Message( - _fbb, - hpfs_response_type, - hpfs_response, - hash__, - path__, - mount_id); -} - -struct Fs_Entry_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Fs_Entry_ResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENTRIES = 4 - }; - const flatbuffers::Vector> *entries() const { - return GetPointer> *>(VT_ENTRIES); - } - flatbuffers::Vector> *mutable_entries() { - return GetPointer> *>(VT_ENTRIES); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ENTRIES) && - verifier.VerifyVector(entries()) && - verifier.VerifyVectorOfTables(entries()) && - verifier.EndTable(); - } -}; - -struct Fs_Entry_ResponseBuilder { - typedef Fs_Entry_Response Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_entries(flatbuffers::Offset>> entries) { - fbb_.AddOffset(Fs_Entry_Response::VT_ENTRIES, entries); - } - explicit Fs_Entry_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateFs_Entry_Response( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> entries = 0) { - Fs_Entry_ResponseBuilder builder_(_fbb); - builder_.add_entries(entries); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateFs_Entry_ResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *entries = nullptr) { - auto entries__ = entries ? _fbb.CreateVector>(*entries) : 0; - return msg::fbuf::p2pmsg::CreateFs_Entry_Response( - _fbb, - entries__); -} - -struct File_HashMap_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef File_HashMap_ResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FILE_LENGTH = 4, - VT_HASH_MAP = 6 - }; - uint64_t file_length() const { - return GetField(VT_FILE_LENGTH, 0); - } - bool mutate_file_length(uint64_t _file_length) { - return SetField(VT_FILE_LENGTH, _file_length, 0); - } - const flatbuffers::Vector *hash_map() const { - return GetPointer *>(VT_HASH_MAP); - } - flatbuffers::Vector *mutable_hash_map() { - return GetPointer *>(VT_HASH_MAP); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_FILE_LENGTH) && - VerifyOffset(verifier, VT_HASH_MAP) && - verifier.VerifyVector(hash_map()) && - verifier.EndTable(); - } -}; - -struct File_HashMap_ResponseBuilder { - typedef File_HashMap_Response Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_file_length(uint64_t file_length) { - fbb_.AddElement(File_HashMap_Response::VT_FILE_LENGTH, file_length, 0); - } - void add_hash_map(flatbuffers::Offset> hash_map) { - fbb_.AddOffset(File_HashMap_Response::VT_HASH_MAP, hash_map); - } - explicit File_HashMap_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateFile_HashMap_Response( - flatbuffers::FlatBufferBuilder &_fbb, - uint64_t file_length = 0, - flatbuffers::Offset> hash_map = 0) { - File_HashMap_ResponseBuilder builder_(_fbb); - builder_.add_file_length(file_length); - builder_.add_hash_map(hash_map); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateFile_HashMap_ResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint64_t file_length = 0, - const std::vector *hash_map = nullptr) { - auto hash_map__ = hash_map ? _fbb.CreateVector(*hash_map) : 0; - return msg::fbuf::p2pmsg::CreateFile_HashMap_Response( - _fbb, - file_length, - hash_map__); -} - -struct Block_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Block_ResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_BLOCK_ID = 4, - VT_DATA = 6 - }; - uint32_t block_id() const { - return GetField(VT_BLOCK_ID, 0); - } - bool mutate_block_id(uint32_t _block_id) { - return SetField(VT_BLOCK_ID, _block_id, 0); - } - const flatbuffers::Vector *data() const { - return GetPointer *>(VT_DATA); - } - flatbuffers::Vector *mutable_data() { - return GetPointer *>(VT_DATA); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_BLOCK_ID) && - VerifyOffset(verifier, VT_DATA) && - verifier.VerifyVector(data()) && - verifier.EndTable(); - } -}; - -struct Block_ResponseBuilder { - typedef Block_Response Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_block_id(uint32_t block_id) { - fbb_.AddElement(Block_Response::VT_BLOCK_ID, block_id, 0); - } - void add_data(flatbuffers::Offset> data) { - fbb_.AddOffset(Block_Response::VT_DATA, data); - } - explicit Block_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateBlock_Response( - flatbuffers::FlatBufferBuilder &_fbb, - uint32_t block_id = 0, - flatbuffers::Offset> data = 0) { - Block_ResponseBuilder builder_(_fbb); - builder_.add_data(data); - builder_.add_block_id(block_id); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateBlock_ResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - uint32_t block_id = 0, - const std::vector *data = nullptr) { - auto data__ = data ? _fbb.CreateVector(*data) : 0; - return msg::fbuf::p2pmsg::CreateBlock_Response( - _fbb, - block_id, - data__); -} - -struct Hpfs_FS_Hash_Entry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Hpfs_FS_Hash_EntryBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_NAME = 4, - VT_IS_FILE = 6, - VT_HASH = 8 - }; - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); - } - flatbuffers::String *mutable_name() { - return GetPointer(VT_NAME); - } - bool is_file() const { - return GetField(VT_IS_FILE, 0) != 0; - } - bool mutate_is_file(bool _is_file) { - return SetField(VT_IS_FILE, static_cast(_is_file), 0); - } - const flatbuffers::Vector *hash() const { - return GetPointer *>(VT_HASH); - } - flatbuffers::Vector *mutable_hash() { - return GetPointer *>(VT_HASH); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_NAME) && - verifier.VerifyString(name()) && - VerifyField(verifier, VT_IS_FILE) && - VerifyOffset(verifier, VT_HASH) && - verifier.VerifyVector(hash()) && - verifier.EndTable(); - } -}; - -struct Hpfs_FS_Hash_EntryBuilder { - typedef Hpfs_FS_Hash_Entry Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_name(flatbuffers::Offset name) { - fbb_.AddOffset(Hpfs_FS_Hash_Entry::VT_NAME, name); - } - void add_is_file(bool is_file) { - fbb_.AddElement(Hpfs_FS_Hash_Entry::VT_IS_FILE, static_cast(is_file), 0); - } - void add_hash(flatbuffers::Offset> hash) { - fbb_.AddOffset(Hpfs_FS_Hash_Entry::VT_HASH, hash); - } - explicit Hpfs_FS_Hash_EntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateHpfs_FS_Hash_Entry( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset name = 0, - bool is_file = false, - flatbuffers::Offset> hash = 0) { - Hpfs_FS_Hash_EntryBuilder builder_(_fbb); - builder_.add_hash(hash); - builder_.add_name(name); - builder_.add_is_file(is_file); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateHpfs_FS_Hash_EntryDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *name = nullptr, - bool is_file = false, - const std::vector *hash = nullptr) { - auto name__ = name ? _fbb.CreateString(name) : 0; - auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; - return msg::fbuf::p2pmsg::CreateHpfs_FS_Hash_Entry( - _fbb, - name__, - is_file, - hash__); -} - -struct Peer_Requirement_Announcement_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_Requirement_Announcement_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_NEED_CONSENSUS_MSG_FORWARDING = 4 - }; - bool need_consensus_msg_forwarding() const { - return GetField(VT_NEED_CONSENSUS_MSG_FORWARDING, 0) != 0; - } - bool mutate_need_consensus_msg_forwarding(bool _need_consensus_msg_forwarding) { - return SetField(VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast(_need_consensus_msg_forwarding), 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_NEED_CONSENSUS_MSG_FORWARDING) && - verifier.EndTable(); - } -}; - -struct Peer_Requirement_Announcement_MessageBuilder { - typedef Peer_Requirement_Announcement_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_need_consensus_msg_forwarding(bool need_consensus_msg_forwarding) { - fbb_.AddElement(Peer_Requirement_Announcement_Message::VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast(need_consensus_msg_forwarding), 0); - } - explicit Peer_Requirement_Announcement_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_Requirement_Announcement_Message( - flatbuffers::FlatBufferBuilder &_fbb, - bool need_consensus_msg_forwarding = false) { - Peer_Requirement_Announcement_MessageBuilder builder_(_fbb); - builder_.add_need_consensus_msg_forwarding(need_consensus_msg_forwarding); - return builder_.Finish(); -} - -struct Available_Capacity_Announcement_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Available_Capacity_Announcement_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_AVAILABLE_CAPACITY = 4, - VT_TIMESTAMP = 6 - }; - int16_t available_capacity() const { - return GetField(VT_AVAILABLE_CAPACITY, 0); - } - bool mutate_available_capacity(int16_t _available_capacity) { - return SetField(VT_AVAILABLE_CAPACITY, _available_capacity, 0); - } - uint64_t timestamp() const { - return GetField(VT_TIMESTAMP, 0); - } - bool mutate_timestamp(uint64_t _timestamp) { - return SetField(VT_TIMESTAMP, _timestamp, 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_AVAILABLE_CAPACITY) && - VerifyField(verifier, VT_TIMESTAMP) && - verifier.EndTable(); - } -}; - -struct Available_Capacity_Announcement_MessageBuilder { - typedef Available_Capacity_Announcement_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_available_capacity(int16_t available_capacity) { - fbb_.AddElement(Available_Capacity_Announcement_Message::VT_AVAILABLE_CAPACITY, available_capacity, 0); - } - void add_timestamp(uint64_t timestamp) { - fbb_.AddElement(Available_Capacity_Announcement_Message::VT_TIMESTAMP, timestamp, 0); - } - explicit Available_Capacity_Announcement_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateAvailable_Capacity_Announcement_Message( - flatbuffers::FlatBufferBuilder &_fbb, - int16_t available_capacity = 0, - uint64_t timestamp = 0) { - Available_Capacity_Announcement_MessageBuilder builder_(_fbb); - builder_.add_timestamp(timestamp); - builder_.add_available_capacity(available_capacity); - return builder_.Finish(); -} - -struct Peer_List_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_List_Request_MessageBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; - -struct Peer_List_Request_MessageBuilder { - typedef Peer_List_Request_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit Peer_List_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_List_Request_Message( - flatbuffers::FlatBufferBuilder &_fbb) { - Peer_List_Request_MessageBuilder builder_(_fbb); - return builder_.Finish(); -} - -struct Peer_List_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_List_Response_MessageBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PEER_LIST = 4 - }; - const flatbuffers::Vector> *peer_list() const { - return GetPointer> *>(VT_PEER_LIST); - } - flatbuffers::Vector> *mutable_peer_list() { - return GetPointer> *>(VT_PEER_LIST); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_PEER_LIST) && - verifier.VerifyVector(peer_list()) && - verifier.VerifyVectorOfTables(peer_list()) && - verifier.EndTable(); - } -}; - -struct Peer_List_Response_MessageBuilder { - typedef Peer_List_Response_Message Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_peer_list(flatbuffers::Offset>> peer_list) { - fbb_.AddOffset(Peer_List_Response_Message::VT_PEER_LIST, peer_list); - } - explicit Peer_List_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_List_Response_Message( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> peer_list = 0) { - Peer_List_Response_MessageBuilder builder_(_fbb); - builder_.add_peer_list(peer_list); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreatePeer_List_Response_MessageDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *peer_list = nullptr) { - auto peer_list__ = peer_list ? _fbb.CreateVector>(*peer_list) : 0; - return msg::fbuf::p2pmsg::CreatePeer_List_Response_Message( - _fbb, - peer_list__); -} - -struct Peer_Properties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef Peer_PropertiesBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_HOST_ADDRESS = 4, - VT_PORT = 6, - VT_AVAILABLE_CAPACITY = 8, - VT_TIMESTAMP = 10 - }; - const flatbuffers::String *host_address() const { - return GetPointer(VT_HOST_ADDRESS); - } - flatbuffers::String *mutable_host_address() { - return GetPointer(VT_HOST_ADDRESS); - } - uint16_t port() const { - return GetField(VT_PORT, 0); - } - bool mutate_port(uint16_t _port) { - return SetField(VT_PORT, _port, 0); - } - int16_t available_capacity() const { - return GetField(VT_AVAILABLE_CAPACITY, 0); - } - bool mutate_available_capacity(int16_t _available_capacity) { - return SetField(VT_AVAILABLE_CAPACITY, _available_capacity, 0); - } - uint64_t timestamp() const { - return GetField(VT_TIMESTAMP, 0); - } - bool mutate_timestamp(uint64_t _timestamp) { - return SetField(VT_TIMESTAMP, _timestamp, 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_HOST_ADDRESS) && - verifier.VerifyString(host_address()) && - VerifyField(verifier, VT_PORT) && - VerifyField(verifier, VT_AVAILABLE_CAPACITY) && - VerifyField(verifier, VT_TIMESTAMP) && - verifier.EndTable(); - } -}; - -struct Peer_PropertiesBuilder { - typedef Peer_Properties Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_host_address(flatbuffers::Offset host_address) { - fbb_.AddOffset(Peer_Properties::VT_HOST_ADDRESS, host_address); - } - void add_port(uint16_t port) { - fbb_.AddElement(Peer_Properties::VT_PORT, port, 0); - } - void add_available_capacity(int16_t available_capacity) { - fbb_.AddElement(Peer_Properties::VT_AVAILABLE_CAPACITY, available_capacity, 0); - } - void add_timestamp(uint64_t timestamp) { - fbb_.AddElement(Peer_Properties::VT_TIMESTAMP, timestamp, 0); - } - explicit Peer_PropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreatePeer_Properties( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset host_address = 0, - uint16_t port = 0, - int16_t available_capacity = 0, - uint64_t timestamp = 0) { - Peer_PropertiesBuilder builder_(_fbb); - builder_.add_timestamp(timestamp); - builder_.add_host_address(host_address); - builder_.add_available_capacity(available_capacity); - builder_.add_port(port); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreatePeer_PropertiesDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *host_address = nullptr, - uint16_t port = 0, - int16_t available_capacity = 0, - uint64_t timestamp = 0) { - auto host_address__ = host_address ? _fbb.CreateString(host_address) : 0; - return msg::fbuf::p2pmsg::CreatePeer_Properties( - _fbb, - host_address__, - port, - available_capacity, - timestamp); -} - -inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type) { - switch (type) { - case Message_NONE: { - return true; - } - case Message_Peer_Challenge_Response_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Peer_Challenge_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_NonUnl_Proposal_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Proposal_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Npl_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Hpfs_Request_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Hpfs_Response_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Peer_Requirement_Announcement_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Peer_List_Request_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Peer_List_Response_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Message_Available_Capacity_Announcement_Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyMessage( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyHpfs_Response(flatbuffers::Verifier &verifier, const void *obj, Hpfs_Response type) { - switch (type) { - case Hpfs_Response_NONE: { - return true; - } - case Hpfs_Response_File_HashMap_Response: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Hpfs_Response_Block_Response: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Hpfs_Response_Fs_Entry_Response: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyHpfs_ResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyHpfs_Response( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline const msg::fbuf::p2pmsg::Content *GetContent(const void *buf) { - return flatbuffers::GetRoot(buf); -} - -inline const msg::fbuf::p2pmsg::Content *GetSizePrefixedContent(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); -} - -inline Content *GetMutableContent(void *buf) { - return flatbuffers::GetMutableRoot(buf); -} - -inline bool VerifyContentBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); -} - -inline bool VerifySizePrefixedContentBuffer( - flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); -} - -inline void FinishContentBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.Finish(root); -} - -inline void FinishSizePrefixedContentBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { - fbb.FinishSizePrefixed(root); -} - -} // namespace p2pmsg -} // namespace fbuf -} // namespace msg - -#endif // FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_ diff --git a/src/msg/fbuf/p2pmsg_conversion.cpp b/src/msg/fbuf/p2pmsg_conversion.cpp new file mode 100644 index 00000000..0a30c07d --- /dev/null +++ b/src/msg/fbuf/p2pmsg_conversion.cpp @@ -0,0 +1,554 @@ +#include "../../hpfs/hpfs_mount.hpp" +#include "../../unl.hpp" +#include "../../crypto.hpp" +#include "../../p2p/p2p.hpp" +#include "common_helpers.hpp" +#include "flatbuf_hasher.hpp" +#include "p2pmsg_conversion.hpp" + +namespace msg::fbuf::p2pmsg +{ + // Length of a peer connection challange. + constexpr size_t PEERCHALLENGE_LEN = 16; + + // Max size of messages which are subjected to time (too old) check. + constexpr size_t MAX_SIZE_FOR_TIME_CHECK = 1 * 1024 * 1024; // 1 MB + + /** + * This section contains Flatbuffer message reading/writing helpers. + * These helpers are mainly used by peer_session_handler and other components which sends outgoing p2p messages. + * + * A p2p flatbuffer message is a bucket with hp version and the message 'content'. + */ + + //---Flatbuf to std---// + + bool verify_peer_message(std::string_view message) + { + // Accessing message buffer + const uint8_t *buf = reinterpret_cast(message.data()); + const size_t buf_size = message.size(); + + // Verify container message using flatbuffer verifier + flatbuffers::Verifier verifier(buf, buf_size, 16, 100); + return VerifyP2PMsgBuffer(verifier); + } + + const p2p::peer_message_info get_peer_message_info(std::string_view message) + { + const auto p2p_msg = p2pmsg::GetP2PMsg(message.data()); + + // Check message timestamp (ignore this for large messages). + if (message.size() <= MAX_SIZE_FOR_TIME_CHECK) + { + const uint64_t time_now = util::get_epoch_milliseconds(); + if (p2p_msg->created_on() < (time_now - (conf::cfg.contract.roundtime * 4))) + { + LOG_DEBUG << "Peer message is too old."; + return p2p::peer_message_info{NULL, P2PMsgContent_NONE, 0}; + } + } + + return p2p::peer_message_info{p2p_msg, p2p_msg->content_type(), p2p_msg->created_on()}; + } + + bool verify_proposal_msg_signature(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_ProposalMsg(); + + // Get hash of proposal data field values and verify the signature against the hash. + flatbuf_hasher hasher; + hasher.add(msg.stage()); + hasher.add(msg.time()); + hasher.add(msg.roundtime()); + hasher.add(msg.nonce()); + hasher.add(msg.users()); + hasher.add(msg.input_hashes()); + hasher.add(msg.output_hash()); + hasher.add(msg.output_sig()); + hasher.add(msg.state_hash()); + hasher.add(msg.patch_hash()); + hasher.add(msg.last_primary_shard_id()); + hasher.add(msg.last_blob_shard_id()); + + return crypto::verify(hasher.hash(), flatbuf_bytes_to_sv(msg.sig()), flatbuf_bytes_to_sv(msg.pubkey())) == 0; + } + + bool verify_npl_msg_signature(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_NplMsg(); + + // Get hash of npl message field values and verify the signature against the hash. + flatbuf_hasher hasher; + hasher.add(msg.data()); + hasher.add(msg.lcl_id()); + + return crypto::verify(hasher.hash(), flatbuf_bytes_to_sv(msg.sig()), flatbuf_bytes_to_sv(msg.pubkey())) == 0; + } + + const p2p::peer_challenge create_peer_challenge_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_PeerChallengeMsg(); + return { + std::string(flatbuf_str_to_sv(msg.contract_id())), + msg.roundtime(), + std::string(flatbuf_bytes_to_sv(msg.challenge()))}; + } + + const p2p::peer_challenge_response create_peer_challenge_response_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_PeerChallengeResponseMsg(); + return { + std::string(flatbuf_bytes_to_sv(msg.challenge())), + std::string(flatbuf_bytes_to_sv(msg.sig())), + std::string(flatbuf_bytes_to_sv(msg.pubkey()))}; + } + + const p2p::proposal create_proposal_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_ProposalMsg(); + + p2p::proposal p; + p.pubkey = flatbuf_bytes_to_sv(msg.pubkey()); + p.sent_timestamp = mi.originated_on; + p.recv_timestamp = util::get_epoch_milliseconds(); + p.time = msg.time(); + p.roundtime = msg.roundtime(); + p.nonce = flatbuf_bytes_to_sv(msg.nonce()); + p.stage = msg.stage(); + p.state_hash = flatbuf_bytes_to_sv(msg.state_hash()); + p.patch_hash = flatbuf_bytes_to_sv(msg.patch_hash()); + p.last_primary_shard_id = flatbuf_seqhash_to_seqhash(msg.last_primary_shard_id()); + p.last_blob_shard_id = flatbuf_seqhash_to_seqhash(msg.last_blob_shard_id()); + + if (msg.users()) + p.users = flatbuf_bytearrayvector_to_stringlist(msg.users()); + + if (msg.input_hashes()) + p.input_hashes = flatbuf_bytearrayvector_to_stringlist(msg.input_hashes()); + + if (msg.output_hash()) + p.output_hash = flatbuf_bytes_to_sv(msg.output_hash()); + + if (msg.output_sig()) + p.output_sig = flatbuf_bytes_to_sv(msg.output_sig()); + + return p; + } + + const p2p::npl_message create_npl_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_NplMsg(); + return { + std::string(flatbuf_bytes_to_sv(msg.pubkey())), + flatbuf_seqhash_to_seqhash(msg.lcl_id()), + std::string(flatbuf_bytes_to_sv(msg.data()))}; + } + + const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_NonUnlProposalMsg(); + + p2p::nonunl_proposal nup; + if (msg.user_inputs()) + nup.user_inputs = flatbuf_user_input_group_to_user_input_map(msg.user_inputs()); + + return nup; + } + + const std::vector create_peer_list_response_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_PeerListResponseMsg(); + return flatbuf_peer_propertieslist_to_peer_propertiesvector(msg.peer_list()); + } + + const p2p::peer_capacity_announcement create_peer_capacity_announcement_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_PeerCapacityAnnouncementMsg(); + return { + msg.available_capacity(), + msg.timestamp()}; + } + + const p2p::peer_requirement_announcement create_peer_requirement_announcement_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_PeerRequirementAnnouncementMsg(); + return { + msg.need_consensus_msg_forwarding()}; + } + + const p2p::hpfs_request create_hpfs_request_from_msg(const p2p::peer_message_info &mi) + { + const auto &msg = *mi.p2p_msg->content_as_HpfsRequestMsg(); + p2p::hpfs_request hr; + hr.mount_id = msg.mount_id(); + hr.block_id = msg.block_id(); + hr.is_file = msg.is_file(); + hr.parent_path = flatbuf_str_to_sv(msg.parent_path()); + hr.expected_hash = flatbuf_bytes_to_hash(msg.expected_hash()); + return hr; + } + + p2p::sequence_hash flatbuf_seqhash_to_seqhash(const SequenceHash *fbseqhash) + { + return { + fbseqhash->seq_no(), + flatbuf_bytes_to_hash(fbseqhash->hash())}; + } + + const std::set flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector> *fbvec) + { + std::set set; + for (const auto el : *fbvec) + set.emplace(std::string(flatbuf_bytes_to_sv(el->array()))); + return set; + } + + const std::unordered_map> + flatbuf_user_input_group_to_user_input_map(const flatbuffers::Vector> *fbvec) + { + std::unordered_map> map; + map.reserve(fbvec->size()); + for (const UserInputGroup *group : *fbvec) + { + std::list user_inputs_list; + + for (const auto msg : *group->messages()) + { + user_inputs_list.push_back(usr::submitted_user_input{ + std::string(flatbuf_bytes_to_sv(msg->input_container())), + std::string(flatbuf_bytes_to_sv(msg->sig())), + static_cast(msg->protocol())}); + } + + map.emplace(flatbuf_bytes_to_sv(group->pubkey()), std::move(user_inputs_list)); + } + return map; + } + + void flatbuf_hpfsfshashentry_to_hpfsfshashentry(std::unordered_map &fs_entries, const flatbuffers::Vector> *fhashes) + { + for (const HpfsFSHashEntry *f_hash : *fhashes) + { + p2p::hpfs_fs_hash_entry entry; + entry.name = flatbuf_str_to_sv(f_hash->name()); + entry.is_file = f_hash->is_file(); + entry.hash = flatbuf_bytes_to_hash(f_hash->hash()); + + fs_entries.emplace(entry.name, std::move(entry)); + } + } + + const std::vector + flatbuf_peer_propertieslist_to_peer_propertiesvector(const flatbuffers::Vector> *fbvec) + { + std::vector peers; + + for (const PeerProperties *peer : *fbvec) + { + conf::peer_properties properties; + + properties.ip_port.host_address = flatbuf_str_to_sv(peer->host_address()); + properties.ip_port.port = peer->port(); + properties.timestamp = peer->timestamp(); + properties.available_capacity = peer->available_capacity(); + + peers.push_back(properties); + } + return peers; + } + + //---std to Flatbuf---// + + const std::string generate_proposal_signature(const p2p::proposal &p) + { + flatbuf_hasher hasher; + hasher.add(p.stage); + hasher.add(p.time); + hasher.add(p.roundtime); + hasher.add(p.nonce); + hasher.add(p.users); + hasher.add(p.input_hashes); + hasher.add(p.output_hash); + hasher.add(p.output_sig); + hasher.add(p.state_hash); + hasher.add(p.patch_hash); + hasher.add(p.last_primary_shard_id); + hasher.add(p.last_blob_shard_id); + + return crypto::sign(hasher.hash(), conf::cfg.node.private_key); + } + + const std::string generate_npl_signature(std::string_view data, const p2p::sequence_hash &lcl_id) + { + flatbuf_hasher hasher; + hasher.add(data); + hasher.add(lcl_id); + + return crypto::sign(hasher.hash(), conf::cfg.node.private_key); + } + + void create_p2p_msg(flatbuffers::FlatBufferBuilder &builder, const msg::fbuf::p2pmsg::P2PMsgContent content_type, const flatbuffers::Offset content) + { + const auto p2pmsg = CreateP2PMsg(builder, + sv_to_flatbuf_str(builder, conf::cfg.hp_version), + util::get_epoch_milliseconds(), + content_type, + content); + builder.Finish(p2pmsg); + } + + void create_msg_from_peer_challenge(flatbuffers::FlatBufferBuilder &builder, std::string &challenge) + { + // We calculate the peer challenge to be a random string. + crypto::random_bytes(challenge, PEERCHALLENGE_LEN); + + const auto msg = CreatePeerChallengeMsg( + builder, + sv_to_flatbuf_str(builder, conf::cfg.contract.id), + conf::cfg.contract.roundtime, + sv_to_flatbuf_bytes(builder, challenge)); + create_p2p_msg(builder, P2PMsgContent_PeerChallengeMsg, msg.Union()); + } + + void create_peer_challenge_response_from_challenge(flatbuffers::FlatBufferBuilder &builder, const std::string &challenge) + { + const std::string sig = crypto::sign(challenge, conf::cfg.node.private_key); + const auto msg = CreatePeerChallengeResponseMsg( + builder, + sv_to_flatbuf_bytes(builder, challenge), + sv_to_flatbuf_bytes(builder, conf::cfg.node.public_key), + sv_to_flatbuf_bytes(builder, sig)); + + create_p2p_msg(builder, P2PMsgContent_PeerChallengeResponseMsg, msg.Union()); + } + + void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::nonunl_proposal &nup) + { + const auto msg = CreateNonUnlProposalMsg( + builder, + user_input_map_to_flatbuf_user_input_group(builder, nup.user_inputs)); + + create_p2p_msg(builder, P2PMsgContent_NonUnlProposalMsg, msg.Union()); + } + + void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p) + { + const auto msg = CreateProposalMsg( + builder, + sv_to_flatbuf_bytes(builder, conf::cfg.node.public_key), + sv_to_flatbuf_bytes(builder, generate_proposal_signature(p)), + p.stage, + p.time, + p.roundtime, + sv_to_flatbuf_bytes(builder, p.nonce), + stringlist_to_flatbuf_bytearrayvector(builder, p.users), + stringlist_to_flatbuf_bytearrayvector(builder, p.input_hashes), + sv_to_flatbuf_bytes(builder, p.output_hash), + sv_to_flatbuf_bytes(builder, p.output_sig), + hash_to_flatbuf_bytes(builder, p.state_hash), + hash_to_flatbuf_bytes(builder, p.patch_hash), + seqhash_to_flatbuf_seqhash(builder, p.last_primary_shard_id), + seqhash_to_flatbuf_seqhash(builder, p.last_blob_shard_id)); + + create_p2p_msg(builder, P2PMsgContent_ProposalMsg, msg.Union()); + } + + void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &builder, std::string_view data, const p2p::sequence_hash &lcl_id) + { + const auto msg = CreateNplMsg( + builder, + sv_to_flatbuf_bytes(builder, conf::cfg.node.public_key), + sv_to_flatbuf_bytes(builder, generate_npl_signature(data, lcl_id)), + sv_to_flatbuf_bytes(builder, data), + seqhash_to_flatbuf_seqhash(builder, lcl_id)); + + create_p2p_msg(builder, P2PMsgContent_NplMsg, msg.Union()); + } + + void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &builder, const p2p::hpfs_request &hr) + { + const auto msg = CreateHpfsRequestMsg( + builder, + hr.mount_id, + sv_to_flatbuf_str(builder, hr.parent_path), + hr.is_file, + hr.block_id, + hash_to_flatbuf_bytes(builder, hr.expected_hash)); + + create_p2p_msg(builder, P2PMsgContent_HpfsRequestMsg, msg.Union()); + } + + void create_msg_from_fsentry_response( + flatbuffers::FlatBufferBuilder &builder, const std::string_view path, const uint32_t mount_id, + std::vector &hash_nodes, util::h32 expected_hash) + { + const auto child_msg = CreateHpfsFsEntryResponse( + builder, + hpfsfshashentry_to_flatbuf_hpfsfshashentry(builder, hash_nodes)); + + const auto msg = CreateHpfsResponseMsg( + builder, + hash_to_flatbuf_bytes(builder, expected_hash), + sv_to_flatbuf_str(builder, path), + mount_id, + HpfsResponse_HpfsFsEntryResponse, + child_msg.Union()); + + create_p2p_msg(builder, P2PMsgContent_HpfsResponseMsg, msg.Union()); + } + + void create_msg_from_filehashmap_response( + flatbuffers::FlatBufferBuilder &builder, std::string_view path, const uint32_t mount_id, + std::vector &hashmap, std::size_t file_length, util::h32 expected_hash) + { + std::string_view hashmap_sv(reinterpret_cast(hashmap.data()), hashmap.size() * sizeof(util::h32)); + + const auto child_msg = CreateHpfsFileHashMapResponse( + builder, + file_length, + sv_to_flatbuf_bytes(builder, hashmap_sv)); + + const auto msg = CreateHpfsResponseMsg( + builder, + hash_to_flatbuf_bytes(builder, expected_hash), + sv_to_flatbuf_str(builder, path), + mount_id, + HpfsResponse_HpfsFileHashMapResponse, + child_msg.Union()); + + create_p2p_msg(builder, P2PMsgContent_HpfsResponseMsg, msg.Union()); + } + + void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &builder, p2p::block_response &block_resp, const uint32_t mount_id) + { + const auto child_msg = CreateHpfsBlockResponse( + builder, + block_resp.block_id, + sv_to_flatbuf_bytes(builder, block_resp.data)); + + const auto msg = CreateHpfsResponseMsg( + builder, + hash_to_flatbuf_bytes(builder, block_resp.hash), + sv_to_flatbuf_str(builder, block_resp.path), + mount_id, + HpfsResponse_HpfsBlockResponse, + child_msg.Union()); + + create_p2p_msg(builder, P2PMsgContent_HpfsResponseMsg, msg.Union()); + } + + void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &builder, const bool need_consensus_msg_forwarding) + { + const auto msg = CreatePeerRequirementAnnouncementMsg( + builder, + need_consensus_msg_forwarding); + + create_p2p_msg(builder, P2PMsgContent_PeerRequirementAnnouncementMsg, msg.Union()); + } + + void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &builder, const int16_t &available_capacity, const uint64_t ×tamp) + { + const auto msg = CreatePeerCapacityAnnouncementMsg( + builder, + available_capacity, + timestamp); + + create_p2p_msg(builder, P2PMsgContent_PeerCapacityAnnouncementMsg, msg.Union()); + } + + void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &builder) + { + const auto msg = CreatePeerListRequestMsg(builder); + create_p2p_msg(builder, P2PMsgContent_PeerListRequestMsg, msg.Union()); + } + + void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port) + { + const auto msg = CreatePeerListResponseMsg( + builder, + peer_propertiesvector_to_flatbuf_peer_propertieslist(builder, peers, skipping_ip_port)); + + create_p2p_msg(builder, P2PMsgContent_PeerListResponseMsg, msg.Union()); + } + + const flatbuffers::Offset>> + user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map) + { + std::vector> fbvec; + fbvec.reserve(map.size()); + for (const auto &[pubkey, msglist] : map) + { + std::vector> fbmsgsvec; + for (const usr::submitted_user_input &msg : msglist) + { + fbmsgsvec.push_back(CreateUserInput( + builder, + sv_to_flatbuf_bytes(builder, msg.input_container), + sv_to_flatbuf_bytes(builder, msg.sig), + static_cast(msg.protocol))); + } + + fbvec.push_back(CreateUserInputGroup( + builder, + sv_to_flatbuf_bytes(builder, pubkey), + builder.CreateVector(fbmsgsvec))); + } + return builder.CreateVector(fbvec); + } + + const flatbuffers::Offset>> + hpfsfshashentry_to_flatbuf_hpfsfshashentry( + flatbuffers::FlatBufferBuilder &builder, + std::vector &hash_nodes) + { + std::vector> fbvec; + fbvec.reserve(hash_nodes.size()); + for (auto const &hash_node : hash_nodes) + { + flatbuffers::Offset hpfs_fs_entry = CreateHpfsFSHashEntry( + builder, + sv_to_flatbuf_str(builder, hash_node.name), + hash_node.is_file, + hash_to_flatbuf_bytes(builder, hash_node.hash)); + + fbvec.push_back(hpfs_fs_entry); + } + return builder.CreateVector(fbvec); + } + + const flatbuffers::Offset>> + peer_propertiesvector_to_flatbuf_peer_propertieslist(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port) + { + std::vector> fbvec; + fbvec.reserve(peers.size()); + for (auto peer : peers) + { + // Skipping the requestedc peer from the peer list response. + if (!skipping_ip_port.has_value() || peer.ip_port != skipping_ip_port.value()) + fbvec.push_back(CreatePeerProperties( + builder, + sv_to_flatbuf_str(builder, peer.ip_port.host_address), + peer.ip_port.port, + peer.available_capacity, + peer.timestamp)); + } + return builder.CreateVector(fbvec); + } + + const flatbuffers::Offset + seqhash_to_flatbuf_seqhash(flatbuffers::FlatBufferBuilder &builder, const p2p::sequence_hash &seqhash) + { + return CreateSequenceHash(builder, seqhash.seq_no, hash_to_flatbuf_bytes(builder, seqhash.hash)); + } + + const flatbuffers::Offset>> + stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::set &set) + { + std::vector> fbvec; + fbvec.reserve(set.size()); + for (std::string_view str : set) + fbvec.push_back(CreateByteArray(builder, sv_to_flatbuf_bytes(builder, str))); + return builder.CreateVector(fbvec); + } +} \ No newline at end of file diff --git a/src/msg/fbuf/p2pmsg_conversion.hpp b/src/msg/fbuf/p2pmsg_conversion.hpp new file mode 100644 index 00000000..900a201a --- /dev/null +++ b/src/msg/fbuf/p2pmsg_conversion.hpp @@ -0,0 +1,108 @@ +#ifndef _HP_MSG_FBUF_P2PMSG_CONVERSION_ +#define _HP_MSG_FBUF_P2PMSG_CONVERSION_ + +#include "../../pchheader.hpp" +#include "../../p2p/p2p.hpp" +#include "../../hpfs/hpfs_mount.hpp" +#include "p2pmsg_generated.h" + +namespace msg::fbuf::p2pmsg +{ + + //---Flatbuf to std---// + + bool verify_peer_message(std::string_view message); + + const p2p::peer_message_info get_peer_message_info(std::string_view message); + + bool verify_proposal_msg_signature(const p2p::peer_message_info &mi); + + bool verify_npl_msg_signature(const p2p::peer_message_info &mi); + + const p2p::peer_challenge create_peer_challenge_from_msg(const p2p::peer_message_info &mi); + + const p2p::peer_challenge_response create_peer_challenge_response_from_msg(const p2p::peer_message_info &mi); + + const p2p::proposal create_proposal_from_msg(const p2p::peer_message_info &mi); + + const p2p::npl_message create_npl_from_msg(const p2p::peer_message_info &mi); + + const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const p2p::peer_message_info &mi); + + const std::vector create_peer_list_response_from_msg(const p2p::peer_message_info &mi); + + const p2p::peer_capacity_announcement create_peer_capacity_announcement_from_msg(const p2p::peer_message_info &mi); + + const p2p::peer_requirement_announcement create_peer_requirement_announcement_from_msg(const p2p::peer_message_info &mi); + + const p2p::hpfs_request create_hpfs_request_from_msg(const p2p::peer_message_info &mi); + + p2p::sequence_hash flatbuf_seqhash_to_seqhash(const msg::fbuf::p2pmsg::SequenceHash *fbseqhash); + + const std::set flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector> *fbvec); + + const std::unordered_map> + flatbuf_user_input_group_to_user_input_map(const flatbuffers::Vector> *fbvec); + + void flatbuf_hpfsfshashentry_to_hpfsfshashentry(std::unordered_map &fs_entries, const flatbuffers::Vector> *fhashes); + + const std::vector + flatbuf_peer_propertieslist_to_peer_propertiesvector(const flatbuffers::Vector> *fbvec); + + //---std to Flatbuf---// + + const std::string generate_proposal_signature(const p2p::proposal &p); + + const std::string generate_npl_signature(std::string_view data, const p2p::sequence_hash &lcl_id); + + void create_p2p_msg(flatbuffers::FlatBufferBuilder &builder, const msg::fbuf::p2pmsg::P2PMsgContent content_type, const flatbuffers::Offset content); + + void create_msg_from_peer_challenge(flatbuffers::FlatBufferBuilder &builder, std::string &challenge); + + void create_peer_challenge_response_from_challenge(flatbuffers::FlatBufferBuilder &builder, const std::string &challenge); + + void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::nonunl_proposal &nup); + + void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p); + + void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &builder, std::string_view data, const p2p::sequence_hash &lcl_id); + + void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &builder, const p2p::hpfs_request &hr); + + void create_msg_from_fsentry_response( + flatbuffers::FlatBufferBuilder &builder, const std::string_view path, const uint32_t mount_id, + std::vector &hash_nodes, util::h32 expected_hash); + + void create_msg_from_filehashmap_response( + flatbuffers::FlatBufferBuilder &builder, std::string_view path, const uint32_t mount_id, + std::vector &hashmap, std::size_t file_length, util::h32 expected_hash); + + void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &builder, p2p::block_response &block_resp, const uint32_t mount_id); + + void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &builder, const bool need_consensus_msg_forwarding); + + void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &builder, const int16_t &available_capacity, const uint64_t ×tamp); + + void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &builder); + + void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port); + + const flatbuffers::Offset>> + user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map); + + const flatbuffers::Offset>> + hpfsfshashentry_to_flatbuf_hpfsfshashentry( + flatbuffers::FlatBufferBuilder &builder, + std::vector &hash_nodes); + + const flatbuffers::Offset>> + peer_propertiesvector_to_flatbuf_peer_propertieslist(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port); + + const flatbuffers::Offset + seqhash_to_flatbuf_seqhash(flatbuffers::FlatBufferBuilder &builder, const p2p::sequence_hash &seqhash); + + const flatbuffers::Offset>> + stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::set &set); +} + +#endif diff --git a/src/msg/fbuf/p2pmsg_generated.h b/src/msg/fbuf/p2pmsg_generated.h new file mode 100644 index 00000000..b59b9cc6 --- /dev/null +++ b/src/msg/fbuf/p2pmsg_generated.h @@ -0,0 +1,2272 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_P2PMSG_MSG_FBUF_P2PMSG_H_ +#define FLATBUFFERS_GENERATED_P2PMSG_MSG_FBUF_P2PMSG_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace msg { +namespace fbuf { +namespace p2pmsg { + +struct P2PMsg; +struct P2PMsgBuilder; + +struct PeerChallengeMsg; +struct PeerChallengeMsgBuilder; + +struct PeerChallengeResponseMsg; +struct PeerChallengeResponseMsgBuilder; + +struct UserInput; +struct UserInputBuilder; + +struct UserInputGroup; +struct UserInputGroupBuilder; + +struct NonUnlProposalMsg; +struct NonUnlProposalMsgBuilder; + +struct ProposalMsg; +struct ProposalMsgBuilder; + +struct NplMsg; +struct NplMsgBuilder; + +struct HpfsRequestMsg; +struct HpfsRequestMsgBuilder; + +struct HpfsResponseMsg; +struct HpfsResponseMsgBuilder; + +struct HpfsFsEntryResponse; +struct HpfsFsEntryResponseBuilder; + +struct HpfsFileHashMapResponse; +struct HpfsFileHashMapResponseBuilder; + +struct HpfsBlockResponse; +struct HpfsBlockResponseBuilder; + +struct HpfsFSHashEntry; +struct HpfsFSHashEntryBuilder; + +struct PeerRequirementAnnouncementMsg; +struct PeerRequirementAnnouncementMsgBuilder; + +struct PeerCapacityAnnouncementMsg; +struct PeerCapacityAnnouncementMsgBuilder; + +struct PeerListRequestMsg; +struct PeerListRequestMsgBuilder; + +struct PeerListResponseMsg; +struct PeerListResponseMsgBuilder; + +struct PeerProperties; +struct PeerPropertiesBuilder; + +struct SequenceHash; +struct SequenceHashBuilder; + +struct ByteArray; +struct ByteArrayBuilder; + +enum P2PMsgContent { + P2PMsgContent_NONE = 0, + P2PMsgContent_PeerChallengeMsg = 1, + P2PMsgContent_PeerChallengeResponseMsg = 2, + P2PMsgContent_NonUnlProposalMsg = 3, + P2PMsgContent_ProposalMsg = 4, + P2PMsgContent_NplMsg = 5, + P2PMsgContent_HpfsRequestMsg = 6, + P2PMsgContent_HpfsResponseMsg = 7, + P2PMsgContent_PeerRequirementAnnouncementMsg = 8, + P2PMsgContent_PeerCapacityAnnouncementMsg = 9, + P2PMsgContent_PeerListRequestMsg = 10, + P2PMsgContent_PeerListResponseMsg = 11, + P2PMsgContent_MIN = P2PMsgContent_NONE, + P2PMsgContent_MAX = P2PMsgContent_PeerListResponseMsg +}; + +inline const P2PMsgContent (&EnumValuesP2PMsgContent())[12] { + static const P2PMsgContent values[] = { + P2PMsgContent_NONE, + P2PMsgContent_PeerChallengeMsg, + P2PMsgContent_PeerChallengeResponseMsg, + P2PMsgContent_NonUnlProposalMsg, + P2PMsgContent_ProposalMsg, + P2PMsgContent_NplMsg, + P2PMsgContent_HpfsRequestMsg, + P2PMsgContent_HpfsResponseMsg, + P2PMsgContent_PeerRequirementAnnouncementMsg, + P2PMsgContent_PeerCapacityAnnouncementMsg, + P2PMsgContent_PeerListRequestMsg, + P2PMsgContent_PeerListResponseMsg + }; + return values; +} + +inline const char * const *EnumNamesP2PMsgContent() { + static const char * const names[13] = { + "NONE", + "PeerChallengeMsg", + "PeerChallengeResponseMsg", + "NonUnlProposalMsg", + "ProposalMsg", + "NplMsg", + "HpfsRequestMsg", + "HpfsResponseMsg", + "PeerRequirementAnnouncementMsg", + "PeerCapacityAnnouncementMsg", + "PeerListRequestMsg", + "PeerListResponseMsg", + nullptr + }; + return names; +} + +inline const char *EnumNameP2PMsgContent(P2PMsgContent e) { + if (flatbuffers::IsOutRange(e, P2PMsgContent_NONE, P2PMsgContent_PeerListResponseMsg)) return ""; + const size_t index = static_cast(e); + return EnumNamesP2PMsgContent()[index]; +} + +template struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_NONE; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerChallengeMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerChallengeResponseMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_NonUnlProposalMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_ProposalMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_NplMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_HpfsRequestMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_HpfsResponseMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerRequirementAnnouncementMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerCapacityAnnouncementMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerListRequestMsg; +}; + +template<> struct P2PMsgContentTraits { + static const P2PMsgContent enum_value = P2PMsgContent_PeerListResponseMsg; +}; + +bool VerifyP2PMsgContent(flatbuffers::Verifier &verifier, const void *obj, P2PMsgContent type); +bool VerifyP2PMsgContentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum HpfsResponse { + HpfsResponse_NONE = 0, + HpfsResponse_HpfsFileHashMapResponse = 1, + HpfsResponse_HpfsBlockResponse = 2, + HpfsResponse_HpfsFsEntryResponse = 3, + HpfsResponse_MIN = HpfsResponse_NONE, + HpfsResponse_MAX = HpfsResponse_HpfsFsEntryResponse +}; + +inline const HpfsResponse (&EnumValuesHpfsResponse())[4] { + static const HpfsResponse values[] = { + HpfsResponse_NONE, + HpfsResponse_HpfsFileHashMapResponse, + HpfsResponse_HpfsBlockResponse, + HpfsResponse_HpfsFsEntryResponse + }; + return values; +} + +inline const char * const *EnumNamesHpfsResponse() { + static const char * const names[5] = { + "NONE", + "HpfsFileHashMapResponse", + "HpfsBlockResponse", + "HpfsFsEntryResponse", + nullptr + }; + return names; +} + +inline const char *EnumNameHpfsResponse(HpfsResponse e) { + if (flatbuffers::IsOutRange(e, HpfsResponse_NONE, HpfsResponse_HpfsFsEntryResponse)) return ""; + const size_t index = static_cast(e); + return EnumNamesHpfsResponse()[index]; +} + +template struct HpfsResponseTraits { + static const HpfsResponse enum_value = HpfsResponse_NONE; +}; + +template<> struct HpfsResponseTraits { + static const HpfsResponse enum_value = HpfsResponse_HpfsFileHashMapResponse; +}; + +template<> struct HpfsResponseTraits { + static const HpfsResponse enum_value = HpfsResponse_HpfsBlockResponse; +}; + +template<> struct HpfsResponseTraits { + static const HpfsResponse enum_value = HpfsResponse_HpfsFsEntryResponse; +}; + +bool VerifyHpfsResponse(flatbuffers::Verifier &verifier, const void *obj, HpfsResponse type); +bool VerifyHpfsResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +struct P2PMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef P2PMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_HP_VERSION = 4, + VT_CREATED_ON = 6, + VT_CONTENT_TYPE = 8, + VT_CONTENT = 10 + }; + const flatbuffers::String *hp_version() const { + return GetPointer(VT_HP_VERSION); + } + flatbuffers::String *mutable_hp_version() { + return GetPointer(VT_HP_VERSION); + } + uint64_t created_on() const { + return GetField(VT_CREATED_ON, 0); + } + bool mutate_created_on(uint64_t _created_on) { + return SetField(VT_CREATED_ON, _created_on, 0); + } + msg::fbuf::p2pmsg::P2PMsgContent content_type() const { + return static_cast(GetField(VT_CONTENT_TYPE, 0)); + } + const void *content() const { + return GetPointer(VT_CONTENT); + } + template const T *content_as() const; + const msg::fbuf::p2pmsg::PeerChallengeMsg *content_as_PeerChallengeMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerChallengeMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::PeerChallengeResponseMsg *content_as_PeerChallengeResponseMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerChallengeResponseMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::NonUnlProposalMsg *content_as_NonUnlProposalMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_NonUnlProposalMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::ProposalMsg *content_as_ProposalMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_ProposalMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::NplMsg *content_as_NplMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_NplMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::HpfsRequestMsg *content_as_HpfsRequestMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_HpfsRequestMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::HpfsResponseMsg *content_as_HpfsResponseMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_HpfsResponseMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::PeerRequirementAnnouncementMsg *content_as_PeerRequirementAnnouncementMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerRequirementAnnouncementMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::PeerCapacityAnnouncementMsg *content_as_PeerCapacityAnnouncementMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerCapacityAnnouncementMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::PeerListRequestMsg *content_as_PeerListRequestMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerListRequestMsg ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::PeerListResponseMsg *content_as_PeerListResponseMsg() const { + return content_type() == msg::fbuf::p2pmsg::P2PMsgContent_PeerListResponseMsg ? static_cast(content()) : nullptr; + } + void *mutable_content() { + return GetPointer(VT_CONTENT); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_HP_VERSION) && + verifier.VerifyString(hp_version()) && + VerifyField(verifier, VT_CREATED_ON) && + VerifyField(verifier, VT_CONTENT_TYPE) && + VerifyOffset(verifier, VT_CONTENT) && + VerifyP2PMsgContent(verifier, content(), content_type()) && + verifier.EndTable(); + } +}; + +template<> inline const msg::fbuf::p2pmsg::PeerChallengeMsg *P2PMsg::content_as() const { + return content_as_PeerChallengeMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::PeerChallengeResponseMsg *P2PMsg::content_as() const { + return content_as_PeerChallengeResponseMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::NonUnlProposalMsg *P2PMsg::content_as() const { + return content_as_NonUnlProposalMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::ProposalMsg *P2PMsg::content_as() const { + return content_as_ProposalMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::NplMsg *P2PMsg::content_as() const { + return content_as_NplMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::HpfsRequestMsg *P2PMsg::content_as() const { + return content_as_HpfsRequestMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::HpfsResponseMsg *P2PMsg::content_as() const { + return content_as_HpfsResponseMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::PeerRequirementAnnouncementMsg *P2PMsg::content_as() const { + return content_as_PeerRequirementAnnouncementMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::PeerCapacityAnnouncementMsg *P2PMsg::content_as() const { + return content_as_PeerCapacityAnnouncementMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::PeerListRequestMsg *P2PMsg::content_as() const { + return content_as_PeerListRequestMsg(); +} + +template<> inline const msg::fbuf::p2pmsg::PeerListResponseMsg *P2PMsg::content_as() const { + return content_as_PeerListResponseMsg(); +} + +struct P2PMsgBuilder { + typedef P2PMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_hp_version(flatbuffers::Offset hp_version) { + fbb_.AddOffset(P2PMsg::VT_HP_VERSION, hp_version); + } + void add_created_on(uint64_t created_on) { + fbb_.AddElement(P2PMsg::VT_CREATED_ON, created_on, 0); + } + void add_content_type(msg::fbuf::p2pmsg::P2PMsgContent content_type) { + fbb_.AddElement(P2PMsg::VT_CONTENT_TYPE, static_cast(content_type), 0); + } + void add_content(flatbuffers::Offset content) { + fbb_.AddOffset(P2PMsg::VT_CONTENT, content); + } + explicit P2PMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + P2PMsgBuilder &operator=(const P2PMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateP2PMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset hp_version = 0, + uint64_t created_on = 0, + msg::fbuf::p2pmsg::P2PMsgContent content_type = msg::fbuf::p2pmsg::P2PMsgContent_NONE, + flatbuffers::Offset content = 0) { + P2PMsgBuilder builder_(_fbb); + builder_.add_created_on(created_on); + builder_.add_content(content); + builder_.add_hp_version(hp_version); + builder_.add_content_type(content_type); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateP2PMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *hp_version = nullptr, + uint64_t created_on = 0, + msg::fbuf::p2pmsg::P2PMsgContent content_type = msg::fbuf::p2pmsg::P2PMsgContent_NONE, + flatbuffers::Offset content = 0) { + auto hp_version__ = hp_version ? _fbb.CreateString(hp_version) : 0; + return msg::fbuf::p2pmsg::CreateP2PMsg( + _fbb, + hp_version__, + created_on, + content_type, + content); +} + +struct PeerChallengeMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerChallengeMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CONTRACT_ID = 4, + VT_ROUNDTIME = 6, + VT_CHALLENGE = 8 + }; + const flatbuffers::String *contract_id() const { + return GetPointer(VT_CONTRACT_ID); + } + flatbuffers::String *mutable_contract_id() { + return GetPointer(VT_CONTRACT_ID); + } + uint32_t roundtime() const { + return GetField(VT_ROUNDTIME, 0); + } + bool mutate_roundtime(uint32_t _roundtime) { + return SetField(VT_ROUNDTIME, _roundtime, 0); + } + const flatbuffers::Vector *challenge() const { + return GetPointer *>(VT_CHALLENGE); + } + flatbuffers::Vector *mutable_challenge() { + return GetPointer *>(VT_CHALLENGE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_CONTRACT_ID) && + verifier.VerifyString(contract_id()) && + VerifyField(verifier, VT_ROUNDTIME) && + VerifyOffset(verifier, VT_CHALLENGE) && + verifier.VerifyVector(challenge()) && + verifier.EndTable(); + } +}; + +struct PeerChallengeMsgBuilder { + typedef PeerChallengeMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_contract_id(flatbuffers::Offset contract_id) { + fbb_.AddOffset(PeerChallengeMsg::VT_CONTRACT_ID, contract_id); + } + void add_roundtime(uint32_t roundtime) { + fbb_.AddElement(PeerChallengeMsg::VT_ROUNDTIME, roundtime, 0); + } + void add_challenge(flatbuffers::Offset> challenge) { + fbb_.AddOffset(PeerChallengeMsg::VT_CHALLENGE, challenge); + } + explicit PeerChallengeMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerChallengeMsgBuilder &operator=(const PeerChallengeMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerChallengeMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset contract_id = 0, + uint32_t roundtime = 0, + flatbuffers::Offset> challenge = 0) { + PeerChallengeMsgBuilder builder_(_fbb); + builder_.add_challenge(challenge); + builder_.add_roundtime(roundtime); + builder_.add_contract_id(contract_id); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePeerChallengeMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *contract_id = nullptr, + uint32_t roundtime = 0, + const std::vector *challenge = nullptr) { + auto contract_id__ = contract_id ? _fbb.CreateString(contract_id) : 0; + auto challenge__ = challenge ? _fbb.CreateVector(*challenge) : 0; + return msg::fbuf::p2pmsg::CreatePeerChallengeMsg( + _fbb, + contract_id__, + roundtime, + challenge__); +} + +struct PeerChallengeResponseMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerChallengeResponseMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CHALLENGE = 4, + VT_PUBKEY = 6, + VT_SIG = 8 + }; + const flatbuffers::Vector *challenge() const { + return GetPointer *>(VT_CHALLENGE); + } + flatbuffers::Vector *mutable_challenge() { + return GetPointer *>(VT_CHALLENGE); + } + const flatbuffers::Vector *pubkey() const { + return GetPointer *>(VT_PUBKEY); + } + flatbuffers::Vector *mutable_pubkey() { + return GetPointer *>(VT_PUBKEY); + } + const flatbuffers::Vector *sig() const { + return GetPointer *>(VT_SIG); + } + flatbuffers::Vector *mutable_sig() { + return GetPointer *>(VT_SIG); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_CHALLENGE) && + verifier.VerifyVector(challenge()) && + VerifyOffset(verifier, VT_PUBKEY) && + verifier.VerifyVector(pubkey()) && + VerifyOffset(verifier, VT_SIG) && + verifier.VerifyVector(sig()) && + verifier.EndTable(); + } +}; + +struct PeerChallengeResponseMsgBuilder { + typedef PeerChallengeResponseMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_challenge(flatbuffers::Offset> challenge) { + fbb_.AddOffset(PeerChallengeResponseMsg::VT_CHALLENGE, challenge); + } + void add_pubkey(flatbuffers::Offset> pubkey) { + fbb_.AddOffset(PeerChallengeResponseMsg::VT_PUBKEY, pubkey); + } + void add_sig(flatbuffers::Offset> sig) { + fbb_.AddOffset(PeerChallengeResponseMsg::VT_SIG, sig); + } + explicit PeerChallengeResponseMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerChallengeResponseMsgBuilder &operator=(const PeerChallengeResponseMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerChallengeResponseMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> challenge = 0, + flatbuffers::Offset> pubkey = 0, + flatbuffers::Offset> sig = 0) { + PeerChallengeResponseMsgBuilder builder_(_fbb); + builder_.add_sig(sig); + builder_.add_pubkey(pubkey); + builder_.add_challenge(challenge); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePeerChallengeResponseMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *challenge = nullptr, + const std::vector *pubkey = nullptr, + const std::vector *sig = nullptr) { + auto challenge__ = challenge ? _fbb.CreateVector(*challenge) : 0; + auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; + auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; + return msg::fbuf::p2pmsg::CreatePeerChallengeResponseMsg( + _fbb, + challenge__, + pubkey__, + sig__); +} + +struct UserInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UserInputBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_CONTAINER = 4, + VT_SIG = 6, + VT_PROTOCOL = 8 + }; + const flatbuffers::Vector *input_container() const { + return GetPointer *>(VT_INPUT_CONTAINER); + } + flatbuffers::Vector *mutable_input_container() { + return GetPointer *>(VT_INPUT_CONTAINER); + } + const flatbuffers::Vector *sig() const { + return GetPointer *>(VT_SIG); + } + flatbuffers::Vector *mutable_sig() { + return GetPointer *>(VT_SIG); + } + uint8_t protocol() const { + return GetField(VT_PROTOCOL, 0); + } + bool mutate_protocol(uint8_t _protocol) { + return SetField(VT_PROTOCOL, _protocol, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_INPUT_CONTAINER) && + verifier.VerifyVector(input_container()) && + VerifyOffset(verifier, VT_SIG) && + verifier.VerifyVector(sig()) && + VerifyField(verifier, VT_PROTOCOL) && + verifier.EndTable(); + } +}; + +struct UserInputBuilder { + typedef UserInput Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_container(flatbuffers::Offset> input_container) { + fbb_.AddOffset(UserInput::VT_INPUT_CONTAINER, input_container); + } + void add_sig(flatbuffers::Offset> sig) { + fbb_.AddOffset(UserInput::VT_SIG, sig); + } + void add_protocol(uint8_t protocol) { + fbb_.AddElement(UserInput::VT_PROTOCOL, protocol, 0); + } + explicit UserInputBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UserInputBuilder &operator=(const UserInputBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUserInput( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> input_container = 0, + flatbuffers::Offset> sig = 0, + uint8_t protocol = 0) { + UserInputBuilder builder_(_fbb); + builder_.add_sig(sig); + builder_.add_input_container(input_container); + builder_.add_protocol(protocol); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateUserInputDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *input_container = nullptr, + const std::vector *sig = nullptr, + uint8_t protocol = 0) { + auto input_container__ = input_container ? _fbb.CreateVector(*input_container) : 0; + auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; + return msg::fbuf::p2pmsg::CreateUserInput( + _fbb, + input_container__, + sig__, + protocol); +} + +struct UserInputGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UserInputGroupBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PUBKEY = 4, + VT_MESSAGES = 6 + }; + const flatbuffers::Vector *pubkey() const { + return GetPointer *>(VT_PUBKEY); + } + flatbuffers::Vector *mutable_pubkey() { + return GetPointer *>(VT_PUBKEY); + } + const flatbuffers::Vector> *messages() const { + return GetPointer> *>(VT_MESSAGES); + } + flatbuffers::Vector> *mutable_messages() { + return GetPointer> *>(VT_MESSAGES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PUBKEY) && + verifier.VerifyVector(pubkey()) && + VerifyOffset(verifier, VT_MESSAGES) && + verifier.VerifyVector(messages()) && + verifier.VerifyVectorOfTables(messages()) && + verifier.EndTable(); + } +}; + +struct UserInputGroupBuilder { + typedef UserInputGroup Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pubkey(flatbuffers::Offset> pubkey) { + fbb_.AddOffset(UserInputGroup::VT_PUBKEY, pubkey); + } + void add_messages(flatbuffers::Offset>> messages) { + fbb_.AddOffset(UserInputGroup::VT_MESSAGES, messages); + } + explicit UserInputGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UserInputGroupBuilder &operator=(const UserInputGroupBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUserInputGroup( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> pubkey = 0, + flatbuffers::Offset>> messages = 0) { + UserInputGroupBuilder builder_(_fbb); + builder_.add_messages(messages); + builder_.add_pubkey(pubkey); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateUserInputGroupDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *pubkey = nullptr, + const std::vector> *messages = nullptr) { + auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; + auto messages__ = messages ? _fbb.CreateVector>(*messages) : 0; + return msg::fbuf::p2pmsg::CreateUserInputGroup( + _fbb, + pubkey__, + messages__); +} + +struct NonUnlProposalMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NonUnlProposalMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_USER_INPUTS = 4 + }; + const flatbuffers::Vector> *user_inputs() const { + return GetPointer> *>(VT_USER_INPUTS); + } + flatbuffers::Vector> *mutable_user_inputs() { + return GetPointer> *>(VT_USER_INPUTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_USER_INPUTS) && + verifier.VerifyVector(user_inputs()) && + verifier.VerifyVectorOfTables(user_inputs()) && + verifier.EndTable(); + } +}; + +struct NonUnlProposalMsgBuilder { + typedef NonUnlProposalMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_user_inputs(flatbuffers::Offset>> user_inputs) { + fbb_.AddOffset(NonUnlProposalMsg::VT_USER_INPUTS, user_inputs); + } + explicit NonUnlProposalMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NonUnlProposalMsgBuilder &operator=(const NonUnlProposalMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNonUnlProposalMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> user_inputs = 0) { + NonUnlProposalMsgBuilder builder_(_fbb); + builder_.add_user_inputs(user_inputs); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateNonUnlProposalMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *user_inputs = nullptr) { + auto user_inputs__ = user_inputs ? _fbb.CreateVector>(*user_inputs) : 0; + return msg::fbuf::p2pmsg::CreateNonUnlProposalMsg( + _fbb, + user_inputs__); +} + +struct ProposalMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ProposalMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PUBKEY = 4, + VT_SIG = 6, + VT_STAGE = 8, + VT_TIME = 10, + VT_ROUNDTIME = 12, + VT_NONCE = 14, + VT_USERS = 16, + VT_INPUT_HASHES = 18, + VT_OUTPUT_HASH = 20, + VT_OUTPUT_SIG = 22, + VT_STATE_HASH = 24, + VT_PATCH_HASH = 26, + VT_LAST_PRIMARY_SHARD_ID = 28, + VT_LAST_BLOB_SHARD_ID = 30 + }; + const flatbuffers::Vector *pubkey() const { + return GetPointer *>(VT_PUBKEY); + } + flatbuffers::Vector *mutable_pubkey() { + return GetPointer *>(VT_PUBKEY); + } + const flatbuffers::Vector *sig() const { + return GetPointer *>(VT_SIG); + } + flatbuffers::Vector *mutable_sig() { + return GetPointer *>(VT_SIG); + } + uint8_t stage() const { + return GetField(VT_STAGE, 0); + } + bool mutate_stage(uint8_t _stage) { + return SetField(VT_STAGE, _stage, 0); + } + uint64_t time() const { + return GetField(VT_TIME, 0); + } + bool mutate_time(uint64_t _time) { + return SetField(VT_TIME, _time, 0); + } + uint32_t roundtime() const { + return GetField(VT_ROUNDTIME, 0); + } + bool mutate_roundtime(uint32_t _roundtime) { + return SetField(VT_ROUNDTIME, _roundtime, 0); + } + const flatbuffers::Vector *nonce() const { + return GetPointer *>(VT_NONCE); + } + flatbuffers::Vector *mutable_nonce() { + return GetPointer *>(VT_NONCE); + } + const flatbuffers::Vector> *users() const { + return GetPointer> *>(VT_USERS); + } + flatbuffers::Vector> *mutable_users() { + return GetPointer> *>(VT_USERS); + } + const flatbuffers::Vector> *input_hashes() const { + return GetPointer> *>(VT_INPUT_HASHES); + } + flatbuffers::Vector> *mutable_input_hashes() { + return GetPointer> *>(VT_INPUT_HASHES); + } + const flatbuffers::Vector *output_hash() const { + return GetPointer *>(VT_OUTPUT_HASH); + } + flatbuffers::Vector *mutable_output_hash() { + return GetPointer *>(VT_OUTPUT_HASH); + } + const flatbuffers::Vector *output_sig() const { + return GetPointer *>(VT_OUTPUT_SIG); + } + flatbuffers::Vector *mutable_output_sig() { + return GetPointer *>(VT_OUTPUT_SIG); + } + const flatbuffers::Vector *state_hash() const { + return GetPointer *>(VT_STATE_HASH); + } + flatbuffers::Vector *mutable_state_hash() { + return GetPointer *>(VT_STATE_HASH); + } + const flatbuffers::Vector *patch_hash() const { + return GetPointer *>(VT_PATCH_HASH); + } + flatbuffers::Vector *mutable_patch_hash() { + return GetPointer *>(VT_PATCH_HASH); + } + const msg::fbuf::p2pmsg::SequenceHash *last_primary_shard_id() const { + return GetPointer(VT_LAST_PRIMARY_SHARD_ID); + } + msg::fbuf::p2pmsg::SequenceHash *mutable_last_primary_shard_id() { + return GetPointer(VT_LAST_PRIMARY_SHARD_ID); + } + const msg::fbuf::p2pmsg::SequenceHash *last_blob_shard_id() const { + return GetPointer(VT_LAST_BLOB_SHARD_ID); + } + msg::fbuf::p2pmsg::SequenceHash *mutable_last_blob_shard_id() { + return GetPointer(VT_LAST_BLOB_SHARD_ID); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PUBKEY) && + verifier.VerifyVector(pubkey()) && + VerifyOffset(verifier, VT_SIG) && + verifier.VerifyVector(sig()) && + VerifyField(verifier, VT_STAGE) && + VerifyField(verifier, VT_TIME) && + VerifyField(verifier, VT_ROUNDTIME) && + VerifyOffset(verifier, VT_NONCE) && + verifier.VerifyVector(nonce()) && + VerifyOffset(verifier, VT_USERS) && + verifier.VerifyVector(users()) && + verifier.VerifyVectorOfTables(users()) && + VerifyOffset(verifier, VT_INPUT_HASHES) && + verifier.VerifyVector(input_hashes()) && + verifier.VerifyVectorOfTables(input_hashes()) && + VerifyOffset(verifier, VT_OUTPUT_HASH) && + verifier.VerifyVector(output_hash()) && + VerifyOffset(verifier, VT_OUTPUT_SIG) && + verifier.VerifyVector(output_sig()) && + VerifyOffset(verifier, VT_STATE_HASH) && + verifier.VerifyVector(state_hash()) && + VerifyOffset(verifier, VT_PATCH_HASH) && + verifier.VerifyVector(patch_hash()) && + VerifyOffset(verifier, VT_LAST_PRIMARY_SHARD_ID) && + verifier.VerifyTable(last_primary_shard_id()) && + VerifyOffset(verifier, VT_LAST_BLOB_SHARD_ID) && + verifier.VerifyTable(last_blob_shard_id()) && + verifier.EndTable(); + } +}; + +struct ProposalMsgBuilder { + typedef ProposalMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pubkey(flatbuffers::Offset> pubkey) { + fbb_.AddOffset(ProposalMsg::VT_PUBKEY, pubkey); + } + void add_sig(flatbuffers::Offset> sig) { + fbb_.AddOffset(ProposalMsg::VT_SIG, sig); + } + void add_stage(uint8_t stage) { + fbb_.AddElement(ProposalMsg::VT_STAGE, stage, 0); + } + void add_time(uint64_t time) { + fbb_.AddElement(ProposalMsg::VT_TIME, time, 0); + } + void add_roundtime(uint32_t roundtime) { + fbb_.AddElement(ProposalMsg::VT_ROUNDTIME, roundtime, 0); + } + void add_nonce(flatbuffers::Offset> nonce) { + fbb_.AddOffset(ProposalMsg::VT_NONCE, nonce); + } + void add_users(flatbuffers::Offset>> users) { + fbb_.AddOffset(ProposalMsg::VT_USERS, users); + } + void add_input_hashes(flatbuffers::Offset>> input_hashes) { + fbb_.AddOffset(ProposalMsg::VT_INPUT_HASHES, input_hashes); + } + void add_output_hash(flatbuffers::Offset> output_hash) { + fbb_.AddOffset(ProposalMsg::VT_OUTPUT_HASH, output_hash); + } + void add_output_sig(flatbuffers::Offset> output_sig) { + fbb_.AddOffset(ProposalMsg::VT_OUTPUT_SIG, output_sig); + } + void add_state_hash(flatbuffers::Offset> state_hash) { + fbb_.AddOffset(ProposalMsg::VT_STATE_HASH, state_hash); + } + void add_patch_hash(flatbuffers::Offset> patch_hash) { + fbb_.AddOffset(ProposalMsg::VT_PATCH_HASH, patch_hash); + } + void add_last_primary_shard_id(flatbuffers::Offset last_primary_shard_id) { + fbb_.AddOffset(ProposalMsg::VT_LAST_PRIMARY_SHARD_ID, last_primary_shard_id); + } + void add_last_blob_shard_id(flatbuffers::Offset last_blob_shard_id) { + fbb_.AddOffset(ProposalMsg::VT_LAST_BLOB_SHARD_ID, last_blob_shard_id); + } + explicit ProposalMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ProposalMsgBuilder &operator=(const ProposalMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateProposalMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> pubkey = 0, + flatbuffers::Offset> sig = 0, + uint8_t stage = 0, + uint64_t time = 0, + uint32_t roundtime = 0, + flatbuffers::Offset> nonce = 0, + flatbuffers::Offset>> users = 0, + flatbuffers::Offset>> input_hashes = 0, + flatbuffers::Offset> output_hash = 0, + flatbuffers::Offset> output_sig = 0, + flatbuffers::Offset> state_hash = 0, + flatbuffers::Offset> patch_hash = 0, + flatbuffers::Offset last_primary_shard_id = 0, + flatbuffers::Offset last_blob_shard_id = 0) { + ProposalMsgBuilder builder_(_fbb); + builder_.add_time(time); + builder_.add_last_blob_shard_id(last_blob_shard_id); + builder_.add_last_primary_shard_id(last_primary_shard_id); + builder_.add_patch_hash(patch_hash); + builder_.add_state_hash(state_hash); + builder_.add_output_sig(output_sig); + builder_.add_output_hash(output_hash); + builder_.add_input_hashes(input_hashes); + builder_.add_users(users); + builder_.add_nonce(nonce); + builder_.add_roundtime(roundtime); + builder_.add_sig(sig); + builder_.add_pubkey(pubkey); + builder_.add_stage(stage); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateProposalMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *pubkey = nullptr, + const std::vector *sig = nullptr, + uint8_t stage = 0, + uint64_t time = 0, + uint32_t roundtime = 0, + const std::vector *nonce = nullptr, + const std::vector> *users = nullptr, + const std::vector> *input_hashes = nullptr, + const std::vector *output_hash = nullptr, + const std::vector *output_sig = nullptr, + const std::vector *state_hash = nullptr, + const std::vector *patch_hash = nullptr, + flatbuffers::Offset last_primary_shard_id = 0, + flatbuffers::Offset last_blob_shard_id = 0) { + auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; + auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; + auto nonce__ = nonce ? _fbb.CreateVector(*nonce) : 0; + auto users__ = users ? _fbb.CreateVector>(*users) : 0; + auto input_hashes__ = input_hashes ? _fbb.CreateVector>(*input_hashes) : 0; + auto output_hash__ = output_hash ? _fbb.CreateVector(*output_hash) : 0; + auto output_sig__ = output_sig ? _fbb.CreateVector(*output_sig) : 0; + auto state_hash__ = state_hash ? _fbb.CreateVector(*state_hash) : 0; + auto patch_hash__ = patch_hash ? _fbb.CreateVector(*patch_hash) : 0; + return msg::fbuf::p2pmsg::CreateProposalMsg( + _fbb, + pubkey__, + sig__, + stage, + time, + roundtime, + nonce__, + users__, + input_hashes__, + output_hash__, + output_sig__, + state_hash__, + patch_hash__, + last_primary_shard_id, + last_blob_shard_id); +} + +struct NplMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NplMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PUBKEY = 4, + VT_SIG = 6, + VT_DATA = 8, + VT_LCL_ID = 10 + }; + const flatbuffers::Vector *pubkey() const { + return GetPointer *>(VT_PUBKEY); + } + flatbuffers::Vector *mutable_pubkey() { + return GetPointer *>(VT_PUBKEY); + } + const flatbuffers::Vector *sig() const { + return GetPointer *>(VT_SIG); + } + flatbuffers::Vector *mutable_sig() { + return GetPointer *>(VT_SIG); + } + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + flatbuffers::Vector *mutable_data() { + return GetPointer *>(VT_DATA); + } + const msg::fbuf::p2pmsg::SequenceHash *lcl_id() const { + return GetPointer(VT_LCL_ID); + } + msg::fbuf::p2pmsg::SequenceHash *mutable_lcl_id() { + return GetPointer(VT_LCL_ID); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PUBKEY) && + verifier.VerifyVector(pubkey()) && + VerifyOffset(verifier, VT_SIG) && + verifier.VerifyVector(sig()) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + VerifyOffset(verifier, VT_LCL_ID) && + verifier.VerifyTable(lcl_id()) && + verifier.EndTable(); + } +}; + +struct NplMsgBuilder { + typedef NplMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pubkey(flatbuffers::Offset> pubkey) { + fbb_.AddOffset(NplMsg::VT_PUBKEY, pubkey); + } + void add_sig(flatbuffers::Offset> sig) { + fbb_.AddOffset(NplMsg::VT_SIG, sig); + } + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(NplMsg::VT_DATA, data); + } + void add_lcl_id(flatbuffers::Offset lcl_id) { + fbb_.AddOffset(NplMsg::VT_LCL_ID, lcl_id); + } + explicit NplMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NplMsgBuilder &operator=(const NplMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNplMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> pubkey = 0, + flatbuffers::Offset> sig = 0, + flatbuffers::Offset> data = 0, + flatbuffers::Offset lcl_id = 0) { + NplMsgBuilder builder_(_fbb); + builder_.add_lcl_id(lcl_id); + builder_.add_data(data); + builder_.add_sig(sig); + builder_.add_pubkey(pubkey); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateNplMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *pubkey = nullptr, + const std::vector *sig = nullptr, + const std::vector *data = nullptr, + flatbuffers::Offset lcl_id = 0) { + auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; + auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return msg::fbuf::p2pmsg::CreateNplMsg( + _fbb, + pubkey__, + sig__, + data__, + lcl_id); +} + +struct HpfsRequestMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsRequestMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MOUNT_ID = 4, + VT_PARENT_PATH = 6, + VT_IS_FILE = 8, + VT_BLOCK_ID = 10, + VT_EXPECTED_HASH = 12 + }; + uint32_t mount_id() const { + return GetField(VT_MOUNT_ID, 0); + } + bool mutate_mount_id(uint32_t _mount_id) { + return SetField(VT_MOUNT_ID, _mount_id, 0); + } + const flatbuffers::String *parent_path() const { + return GetPointer(VT_PARENT_PATH); + } + flatbuffers::String *mutable_parent_path() { + return GetPointer(VT_PARENT_PATH); + } + bool is_file() const { + return GetField(VT_IS_FILE, 0) != 0; + } + bool mutate_is_file(bool _is_file) { + return SetField(VT_IS_FILE, static_cast(_is_file), 0); + } + int32_t block_id() const { + return GetField(VT_BLOCK_ID, 0); + } + bool mutate_block_id(int32_t _block_id) { + return SetField(VT_BLOCK_ID, _block_id, 0); + } + const flatbuffers::Vector *expected_hash() const { + return GetPointer *>(VT_EXPECTED_HASH); + } + flatbuffers::Vector *mutable_expected_hash() { + return GetPointer *>(VT_EXPECTED_HASH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_MOUNT_ID) && + VerifyOffset(verifier, VT_PARENT_PATH) && + verifier.VerifyString(parent_path()) && + VerifyField(verifier, VT_IS_FILE) && + VerifyField(verifier, VT_BLOCK_ID) && + VerifyOffset(verifier, VT_EXPECTED_HASH) && + verifier.VerifyVector(expected_hash()) && + verifier.EndTable(); + } +}; + +struct HpfsRequestMsgBuilder { + typedef HpfsRequestMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_mount_id(uint32_t mount_id) { + fbb_.AddElement(HpfsRequestMsg::VT_MOUNT_ID, mount_id, 0); + } + void add_parent_path(flatbuffers::Offset parent_path) { + fbb_.AddOffset(HpfsRequestMsg::VT_PARENT_PATH, parent_path); + } + void add_is_file(bool is_file) { + fbb_.AddElement(HpfsRequestMsg::VT_IS_FILE, static_cast(is_file), 0); + } + void add_block_id(int32_t block_id) { + fbb_.AddElement(HpfsRequestMsg::VT_BLOCK_ID, block_id, 0); + } + void add_expected_hash(flatbuffers::Offset> expected_hash) { + fbb_.AddOffset(HpfsRequestMsg::VT_EXPECTED_HASH, expected_hash); + } + explicit HpfsRequestMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsRequestMsgBuilder &operator=(const HpfsRequestMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsRequestMsg( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t mount_id = 0, + flatbuffers::Offset parent_path = 0, + bool is_file = false, + int32_t block_id = 0, + flatbuffers::Offset> expected_hash = 0) { + HpfsRequestMsgBuilder builder_(_fbb); + builder_.add_expected_hash(expected_hash); + builder_.add_block_id(block_id); + builder_.add_parent_path(parent_path); + builder_.add_mount_id(mount_id); + builder_.add_is_file(is_file); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsRequestMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t mount_id = 0, + const char *parent_path = nullptr, + bool is_file = false, + int32_t block_id = 0, + const std::vector *expected_hash = nullptr) { + auto parent_path__ = parent_path ? _fbb.CreateString(parent_path) : 0; + auto expected_hash__ = expected_hash ? _fbb.CreateVector(*expected_hash) : 0; + return msg::fbuf::p2pmsg::CreateHpfsRequestMsg( + _fbb, + mount_id, + parent_path__, + is_file, + block_id, + expected_hash__); +} + +struct HpfsResponseMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsResponseMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_HASH = 4, + VT_PATH = 6, + VT_MOUNT_ID = 8, + VT_CONTENT_TYPE = 10, + VT_CONTENT = 12 + }; + const flatbuffers::Vector *hash() const { + return GetPointer *>(VT_HASH); + } + flatbuffers::Vector *mutable_hash() { + return GetPointer *>(VT_HASH); + } + const flatbuffers::String *path() const { + return GetPointer(VT_PATH); + } + flatbuffers::String *mutable_path() { + return GetPointer(VT_PATH); + } + uint32_t mount_id() const { + return GetField(VT_MOUNT_ID, 0); + } + bool mutate_mount_id(uint32_t _mount_id) { + return SetField(VT_MOUNT_ID, _mount_id, 0); + } + msg::fbuf::p2pmsg::HpfsResponse content_type() const { + return static_cast(GetField(VT_CONTENT_TYPE, 0)); + } + const void *content() const { + return GetPointer(VT_CONTENT); + } + template const T *content_as() const; + const msg::fbuf::p2pmsg::HpfsFileHashMapResponse *content_as_HpfsFileHashMapResponse() const { + return content_type() == msg::fbuf::p2pmsg::HpfsResponse_HpfsFileHashMapResponse ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::HpfsBlockResponse *content_as_HpfsBlockResponse() const { + return content_type() == msg::fbuf::p2pmsg::HpfsResponse_HpfsBlockResponse ? static_cast(content()) : nullptr; + } + const msg::fbuf::p2pmsg::HpfsFsEntryResponse *content_as_HpfsFsEntryResponse() const { + return content_type() == msg::fbuf::p2pmsg::HpfsResponse_HpfsFsEntryResponse ? static_cast(content()) : nullptr; + } + void *mutable_content() { + return GetPointer(VT_CONTENT); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_HASH) && + verifier.VerifyVector(hash()) && + VerifyOffset(verifier, VT_PATH) && + verifier.VerifyString(path()) && + VerifyField(verifier, VT_MOUNT_ID) && + VerifyField(verifier, VT_CONTENT_TYPE) && + VerifyOffset(verifier, VT_CONTENT) && + VerifyHpfsResponse(verifier, content(), content_type()) && + verifier.EndTable(); + } +}; + +template<> inline const msg::fbuf::p2pmsg::HpfsFileHashMapResponse *HpfsResponseMsg::content_as() const { + return content_as_HpfsFileHashMapResponse(); +} + +template<> inline const msg::fbuf::p2pmsg::HpfsBlockResponse *HpfsResponseMsg::content_as() const { + return content_as_HpfsBlockResponse(); +} + +template<> inline const msg::fbuf::p2pmsg::HpfsFsEntryResponse *HpfsResponseMsg::content_as() const { + return content_as_HpfsFsEntryResponse(); +} + +struct HpfsResponseMsgBuilder { + typedef HpfsResponseMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_hash(flatbuffers::Offset> hash) { + fbb_.AddOffset(HpfsResponseMsg::VT_HASH, hash); + } + void add_path(flatbuffers::Offset path) { + fbb_.AddOffset(HpfsResponseMsg::VT_PATH, path); + } + void add_mount_id(uint32_t mount_id) { + fbb_.AddElement(HpfsResponseMsg::VT_MOUNT_ID, mount_id, 0); + } + void add_content_type(msg::fbuf::p2pmsg::HpfsResponse content_type) { + fbb_.AddElement(HpfsResponseMsg::VT_CONTENT_TYPE, static_cast(content_type), 0); + } + void add_content(flatbuffers::Offset content) { + fbb_.AddOffset(HpfsResponseMsg::VT_CONTENT, content); + } + explicit HpfsResponseMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsResponseMsgBuilder &operator=(const HpfsResponseMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsResponseMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> hash = 0, + flatbuffers::Offset path = 0, + uint32_t mount_id = 0, + msg::fbuf::p2pmsg::HpfsResponse content_type = msg::fbuf::p2pmsg::HpfsResponse_NONE, + flatbuffers::Offset content = 0) { + HpfsResponseMsgBuilder builder_(_fbb); + builder_.add_content(content); + builder_.add_mount_id(mount_id); + builder_.add_path(path); + builder_.add_hash(hash); + builder_.add_content_type(content_type); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsResponseMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *hash = nullptr, + const char *path = nullptr, + uint32_t mount_id = 0, + msg::fbuf::p2pmsg::HpfsResponse content_type = msg::fbuf::p2pmsg::HpfsResponse_NONE, + flatbuffers::Offset content = 0) { + auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; + auto path__ = path ? _fbb.CreateString(path) : 0; + return msg::fbuf::p2pmsg::CreateHpfsResponseMsg( + _fbb, + hash__, + path__, + mount_id, + content_type, + content); +} + +struct HpfsFsEntryResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsFsEntryResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ENTRIES = 4 + }; + const flatbuffers::Vector> *entries() const { + return GetPointer> *>(VT_ENTRIES); + } + flatbuffers::Vector> *mutable_entries() { + return GetPointer> *>(VT_ENTRIES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ENTRIES) && + verifier.VerifyVector(entries()) && + verifier.VerifyVectorOfTables(entries()) && + verifier.EndTable(); + } +}; + +struct HpfsFsEntryResponseBuilder { + typedef HpfsFsEntryResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_entries(flatbuffers::Offset>> entries) { + fbb_.AddOffset(HpfsFsEntryResponse::VT_ENTRIES, entries); + } + explicit HpfsFsEntryResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsFsEntryResponseBuilder &operator=(const HpfsFsEntryResponseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsFsEntryResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> entries = 0) { + HpfsFsEntryResponseBuilder builder_(_fbb); + builder_.add_entries(entries); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsFsEntryResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *entries = nullptr) { + auto entries__ = entries ? _fbb.CreateVector>(*entries) : 0; + return msg::fbuf::p2pmsg::CreateHpfsFsEntryResponse( + _fbb, + entries__); +} + +struct HpfsFileHashMapResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsFileHashMapResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_FILE_LENGTH = 4, + VT_HASH_MAP = 6 + }; + uint64_t file_length() const { + return GetField(VT_FILE_LENGTH, 0); + } + bool mutate_file_length(uint64_t _file_length) { + return SetField(VT_FILE_LENGTH, _file_length, 0); + } + const flatbuffers::Vector *hash_map() const { + return GetPointer *>(VT_HASH_MAP); + } + flatbuffers::Vector *mutable_hash_map() { + return GetPointer *>(VT_HASH_MAP); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FILE_LENGTH) && + VerifyOffset(verifier, VT_HASH_MAP) && + verifier.VerifyVector(hash_map()) && + verifier.EndTable(); + } +}; + +struct HpfsFileHashMapResponseBuilder { + typedef HpfsFileHashMapResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_file_length(uint64_t file_length) { + fbb_.AddElement(HpfsFileHashMapResponse::VT_FILE_LENGTH, file_length, 0); + } + void add_hash_map(flatbuffers::Offset> hash_map) { + fbb_.AddOffset(HpfsFileHashMapResponse::VT_HASH_MAP, hash_map); + } + explicit HpfsFileHashMapResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsFileHashMapResponseBuilder &operator=(const HpfsFileHashMapResponseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsFileHashMapResponse( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t file_length = 0, + flatbuffers::Offset> hash_map = 0) { + HpfsFileHashMapResponseBuilder builder_(_fbb); + builder_.add_file_length(file_length); + builder_.add_hash_map(hash_map); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsFileHashMapResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t file_length = 0, + const std::vector *hash_map = nullptr) { + auto hash_map__ = hash_map ? _fbb.CreateVector(*hash_map) : 0; + return msg::fbuf::p2pmsg::CreateHpfsFileHashMapResponse( + _fbb, + file_length, + hash_map__); +} + +struct HpfsBlockResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsBlockResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BLOCK_ID = 4, + VT_DATA = 6 + }; + uint32_t block_id() const { + return GetField(VT_BLOCK_ID, 0); + } + bool mutate_block_id(uint32_t _block_id) { + return SetField(VT_BLOCK_ID, _block_id, 0); + } + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + flatbuffers::Vector *mutable_data() { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BLOCK_ID) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct HpfsBlockResponseBuilder { + typedef HpfsBlockResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_block_id(uint32_t block_id) { + fbb_.AddElement(HpfsBlockResponse::VT_BLOCK_ID, block_id, 0); + } + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(HpfsBlockResponse::VT_DATA, data); + } + explicit HpfsBlockResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsBlockResponseBuilder &operator=(const HpfsBlockResponseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsBlockResponse( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t block_id = 0, + flatbuffers::Offset> data = 0) { + HpfsBlockResponseBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_block_id(block_id); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsBlockResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t block_id = 0, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return msg::fbuf::p2pmsg::CreateHpfsBlockResponse( + _fbb, + block_id, + data__); +} + +struct HpfsFSHashEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HpfsFSHashEntryBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_IS_FILE = 6, + VT_HASH = 8 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + bool is_file() const { + return GetField(VT_IS_FILE, 0) != 0; + } + bool mutate_is_file(bool _is_file) { + return SetField(VT_IS_FILE, static_cast(_is_file), 0); + } + const flatbuffers::Vector *hash() const { + return GetPointer *>(VT_HASH); + } + flatbuffers::Vector *mutable_hash() { + return GetPointer *>(VT_HASH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyField(verifier, VT_IS_FILE) && + VerifyOffset(verifier, VT_HASH) && + verifier.VerifyVector(hash()) && + verifier.EndTable(); + } +}; + +struct HpfsFSHashEntryBuilder { + typedef HpfsFSHashEntry Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(HpfsFSHashEntry::VT_NAME, name); + } + void add_is_file(bool is_file) { + fbb_.AddElement(HpfsFSHashEntry::VT_IS_FILE, static_cast(is_file), 0); + } + void add_hash(flatbuffers::Offset> hash) { + fbb_.AddOffset(HpfsFSHashEntry::VT_HASH, hash); + } + explicit HpfsFSHashEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + HpfsFSHashEntryBuilder &operator=(const HpfsFSHashEntryBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHpfsFSHashEntry( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + bool is_file = false, + flatbuffers::Offset> hash = 0) { + HpfsFSHashEntryBuilder builder_(_fbb); + builder_.add_hash(hash); + builder_.add_name(name); + builder_.add_is_file(is_file); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHpfsFSHashEntryDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + bool is_file = false, + const std::vector *hash = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; + return msg::fbuf::p2pmsg::CreateHpfsFSHashEntry( + _fbb, + name__, + is_file, + hash__); +} + +struct PeerRequirementAnnouncementMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerRequirementAnnouncementMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NEED_CONSENSUS_MSG_FORWARDING = 4 + }; + bool need_consensus_msg_forwarding() const { + return GetField(VT_NEED_CONSENSUS_MSG_FORWARDING, 0) != 0; + } + bool mutate_need_consensus_msg_forwarding(bool _need_consensus_msg_forwarding) { + return SetField(VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast(_need_consensus_msg_forwarding), 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NEED_CONSENSUS_MSG_FORWARDING) && + verifier.EndTable(); + } +}; + +struct PeerRequirementAnnouncementMsgBuilder { + typedef PeerRequirementAnnouncementMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_need_consensus_msg_forwarding(bool need_consensus_msg_forwarding) { + fbb_.AddElement(PeerRequirementAnnouncementMsg::VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast(need_consensus_msg_forwarding), 0); + } + explicit PeerRequirementAnnouncementMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerRequirementAnnouncementMsgBuilder &operator=(const PeerRequirementAnnouncementMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerRequirementAnnouncementMsg( + flatbuffers::FlatBufferBuilder &_fbb, + bool need_consensus_msg_forwarding = false) { + PeerRequirementAnnouncementMsgBuilder builder_(_fbb); + builder_.add_need_consensus_msg_forwarding(need_consensus_msg_forwarding); + return builder_.Finish(); +} + +struct PeerCapacityAnnouncementMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerCapacityAnnouncementMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AVAILABLE_CAPACITY = 4, + VT_TIMESTAMP = 6 + }; + int16_t available_capacity() const { + return GetField(VT_AVAILABLE_CAPACITY, 0); + } + bool mutate_available_capacity(int16_t _available_capacity) { + return SetField(VT_AVAILABLE_CAPACITY, _available_capacity, 0); + } + uint64_t timestamp() const { + return GetField(VT_TIMESTAMP, 0); + } + bool mutate_timestamp(uint64_t _timestamp) { + return SetField(VT_TIMESTAMP, _timestamp, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_AVAILABLE_CAPACITY) && + VerifyField(verifier, VT_TIMESTAMP) && + verifier.EndTable(); + } +}; + +struct PeerCapacityAnnouncementMsgBuilder { + typedef PeerCapacityAnnouncementMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_available_capacity(int16_t available_capacity) { + fbb_.AddElement(PeerCapacityAnnouncementMsg::VT_AVAILABLE_CAPACITY, available_capacity, 0); + } + void add_timestamp(uint64_t timestamp) { + fbb_.AddElement(PeerCapacityAnnouncementMsg::VT_TIMESTAMP, timestamp, 0); + } + explicit PeerCapacityAnnouncementMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerCapacityAnnouncementMsgBuilder &operator=(const PeerCapacityAnnouncementMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerCapacityAnnouncementMsg( + flatbuffers::FlatBufferBuilder &_fbb, + int16_t available_capacity = 0, + uint64_t timestamp = 0) { + PeerCapacityAnnouncementMsgBuilder builder_(_fbb); + builder_.add_timestamp(timestamp); + builder_.add_available_capacity(available_capacity); + return builder_.Finish(); +} + +struct PeerListRequestMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerListRequestMsgBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct PeerListRequestMsgBuilder { + typedef PeerListRequestMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit PeerListRequestMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerListRequestMsgBuilder &operator=(const PeerListRequestMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerListRequestMsg( + flatbuffers::FlatBufferBuilder &_fbb) { + PeerListRequestMsgBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct PeerListResponseMsg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerListResponseMsgBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PEER_LIST = 4 + }; + const flatbuffers::Vector> *peer_list() const { + return GetPointer> *>(VT_PEER_LIST); + } + flatbuffers::Vector> *mutable_peer_list() { + return GetPointer> *>(VT_PEER_LIST); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PEER_LIST) && + verifier.VerifyVector(peer_list()) && + verifier.VerifyVectorOfTables(peer_list()) && + verifier.EndTable(); + } +}; + +struct PeerListResponseMsgBuilder { + typedef PeerListResponseMsg Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_peer_list(flatbuffers::Offset>> peer_list) { + fbb_.AddOffset(PeerListResponseMsg::VT_PEER_LIST, peer_list); + } + explicit PeerListResponseMsgBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerListResponseMsgBuilder &operator=(const PeerListResponseMsgBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerListResponseMsg( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> peer_list = 0) { + PeerListResponseMsgBuilder builder_(_fbb); + builder_.add_peer_list(peer_list); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePeerListResponseMsgDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *peer_list = nullptr) { + auto peer_list__ = peer_list ? _fbb.CreateVector>(*peer_list) : 0; + return msg::fbuf::p2pmsg::CreatePeerListResponseMsg( + _fbb, + peer_list__); +} + +struct PeerProperties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PeerPropertiesBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_HOST_ADDRESS = 4, + VT_PORT = 6, + VT_AVAILABLE_CAPACITY = 8, + VT_TIMESTAMP = 10 + }; + const flatbuffers::String *host_address() const { + return GetPointer(VT_HOST_ADDRESS); + } + flatbuffers::String *mutable_host_address() { + return GetPointer(VT_HOST_ADDRESS); + } + uint16_t port() const { + return GetField(VT_PORT, 0); + } + bool mutate_port(uint16_t _port) { + return SetField(VT_PORT, _port, 0); + } + int16_t available_capacity() const { + return GetField(VT_AVAILABLE_CAPACITY, 0); + } + bool mutate_available_capacity(int16_t _available_capacity) { + return SetField(VT_AVAILABLE_CAPACITY, _available_capacity, 0); + } + uint64_t timestamp() const { + return GetField(VT_TIMESTAMP, 0); + } + bool mutate_timestamp(uint64_t _timestamp) { + return SetField(VT_TIMESTAMP, _timestamp, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_HOST_ADDRESS) && + verifier.VerifyString(host_address()) && + VerifyField(verifier, VT_PORT) && + VerifyField(verifier, VT_AVAILABLE_CAPACITY) && + VerifyField(verifier, VT_TIMESTAMP) && + verifier.EndTable(); + } +}; + +struct PeerPropertiesBuilder { + typedef PeerProperties Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_host_address(flatbuffers::Offset host_address) { + fbb_.AddOffset(PeerProperties::VT_HOST_ADDRESS, host_address); + } + void add_port(uint16_t port) { + fbb_.AddElement(PeerProperties::VT_PORT, port, 0); + } + void add_available_capacity(int16_t available_capacity) { + fbb_.AddElement(PeerProperties::VT_AVAILABLE_CAPACITY, available_capacity, 0); + } + void add_timestamp(uint64_t timestamp) { + fbb_.AddElement(PeerProperties::VT_TIMESTAMP, timestamp, 0); + } + explicit PeerPropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PeerPropertiesBuilder &operator=(const PeerPropertiesBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePeerProperties( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset host_address = 0, + uint16_t port = 0, + int16_t available_capacity = 0, + uint64_t timestamp = 0) { + PeerPropertiesBuilder builder_(_fbb); + builder_.add_timestamp(timestamp); + builder_.add_host_address(host_address); + builder_.add_available_capacity(available_capacity); + builder_.add_port(port); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePeerPropertiesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *host_address = nullptr, + uint16_t port = 0, + int16_t available_capacity = 0, + uint64_t timestamp = 0) { + auto host_address__ = host_address ? _fbb.CreateString(host_address) : 0; + return msg::fbuf::p2pmsg::CreatePeerProperties( + _fbb, + host_address__, + port, + available_capacity, + timestamp); +} + +struct SequenceHash FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SequenceHashBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SEQ_NO = 4, + VT_HASH = 6 + }; + uint64_t seq_no() const { + return GetField(VT_SEQ_NO, 0); + } + bool mutate_seq_no(uint64_t _seq_no) { + return SetField(VT_SEQ_NO, _seq_no, 0); + } + const flatbuffers::Vector *hash() const { + return GetPointer *>(VT_HASH); + } + flatbuffers::Vector *mutable_hash() { + return GetPointer *>(VT_HASH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_SEQ_NO) && + VerifyOffset(verifier, VT_HASH) && + verifier.VerifyVector(hash()) && + verifier.EndTable(); + } +}; + +struct SequenceHashBuilder { + typedef SequenceHash Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_seq_no(uint64_t seq_no) { + fbb_.AddElement(SequenceHash::VT_SEQ_NO, seq_no, 0); + } + void add_hash(flatbuffers::Offset> hash) { + fbb_.AddOffset(SequenceHash::VT_HASH, hash); + } + explicit SequenceHashBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SequenceHashBuilder &operator=(const SequenceHashBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSequenceHash( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t seq_no = 0, + flatbuffers::Offset> hash = 0) { + SequenceHashBuilder builder_(_fbb); + builder_.add_seq_no(seq_no); + builder_.add_hash(hash); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSequenceHashDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t seq_no = 0, + const std::vector *hash = nullptr) { + auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; + return msg::fbuf::p2pmsg::CreateSequenceHash( + _fbb, + seq_no, + hash__); +} + +struct ByteArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ByteArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ARRAY = 4 + }; + const flatbuffers::Vector *array() const { + return GetPointer *>(VT_ARRAY); + } + flatbuffers::Vector *mutable_array() { + return GetPointer *>(VT_ARRAY); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ARRAY) && + verifier.VerifyVector(array()) && + verifier.EndTable(); + } +}; + +struct ByteArrayBuilder { + typedef ByteArray Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_array(flatbuffers::Offset> array) { + fbb_.AddOffset(ByteArray::VT_ARRAY, array); + } + explicit ByteArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ByteArrayBuilder &operator=(const ByteArrayBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateByteArray( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> array = 0) { + ByteArrayBuilder builder_(_fbb); + builder_.add_array(array); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateByteArrayDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *array = nullptr) { + auto array__ = array ? _fbb.CreateVector(*array) : 0; + return msg::fbuf::p2pmsg::CreateByteArray( + _fbb, + array__); +} + +inline bool VerifyP2PMsgContent(flatbuffers::Verifier &verifier, const void *obj, P2PMsgContent type) { + switch (type) { + case P2PMsgContent_NONE: { + return true; + } + case P2PMsgContent_PeerChallengeMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_PeerChallengeResponseMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_NonUnlProposalMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_ProposalMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_NplMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_HpfsRequestMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_HpfsResponseMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_PeerRequirementAnnouncementMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_PeerCapacityAnnouncementMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_PeerListRequestMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case P2PMsgContent_PeerListResponseMsg: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyP2PMsgContentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyP2PMsgContent( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyHpfsResponse(flatbuffers::Verifier &verifier, const void *obj, HpfsResponse type) { + switch (type) { + case HpfsResponse_NONE: { + return true; + } + case HpfsResponse_HpfsFileHashMapResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case HpfsResponse_HpfsBlockResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case HpfsResponse_HpfsFsEntryResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyHpfsResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyHpfsResponse( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const msg::fbuf::p2pmsg::P2PMsg *GetP2PMsg(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const msg::fbuf::p2pmsg::P2PMsg *GetSizePrefixedP2PMsg(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline P2PMsg *GetMutableP2PMsg(void *buf) { + return flatbuffers::GetMutableRoot(buf); +} + +inline bool VerifyP2PMsgBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedP2PMsgBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishP2PMsgBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedP2PMsgBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root); +} + +} // namespace p2pmsg +} // namespace fbuf +} // namespace msg + +#endif // FLATBUFFERS_GENERATED_P2PMSG_MSG_FBUF_P2PMSG_H_ diff --git a/src/msg/fbuf/p2pmsg_helpers.cpp b/src/msg/fbuf/p2pmsg_helpers.cpp deleted file mode 100644 index 6ff48e3b..00000000 --- a/src/msg/fbuf/p2pmsg_helpers.cpp +++ /dev/null @@ -1,800 +0,0 @@ -#include "../../pchheader.hpp" -#include "../../conf.hpp" -#include "../../crypto.hpp" -#include "../../util/util.hpp" -#include "../../hplog.hpp" -#include "../../util/h32.hpp" -#include "../../unl.hpp" -#include "p2pmsg_container_generated.h" -#include "p2pmsg_content_generated.h" -#include "common_helpers.hpp" -#include "p2pmsg_helpers.hpp" - -namespace msg::fbuf::p2pmsg -{ - - // Length of a peer connection challange. - constexpr size_t PEERCHALLENGE_LEN = 16; - - // Max size of messages which are subjected to time (too old) check. - constexpr size_t MAX_SIZE_FOR_TIME_CHECK = 1 * 1024 * 1024; // 1 MB - - /** - * This section contains Flatbuffer message reading/writing helpers. - * These helpers are mainly used by peer_session_handler. - * - * All Flatbuffer peer messages are 'Container' messages. 'Container' message is a bucket - * which some common headers (version, singature etc..) and the message 'Content' (Proposal, NPL etc..). - * - * Therefore, when constructing peer messages, we have to first construct 'Content' message and then - * place the 'Content' inside a 'Conatiner. 'Content' and 'Container' messages are constructed using - * Flatbuffer builders. - * - * Reading is also 2 steps because of this. We have first interprit the 'Container' message from the - * received data and then interprit the 'Content' portion of it separately to read the actual content. - */ - - //---Message validation helpers---/ - - /** - * Verifies Conatiner message structure and outputs faltbuffer Container pointer to access the given buffer. - * - * @param container_ref A pointer reference to assign the pointer to the Container object. - * @param container_buf The buffer containing the data that should be validated and interpreted - * via the container pointer. - * @return 0 on successful verification. -1 for failure. - */ - int validate_and_extract_container(const Container **container_ref, std::string_view container_buf) - { - //Accessing message buffer - const uint8_t *container_buf_ptr = reinterpret_cast(container_buf.data()); - const size_t container_buf_size = container_buf.length(); - - //Defining Flatbuffer verifier (default max depth = 64, max_tables = 1000000,) - flatbuffers::Verifier container_verifier(container_buf_ptr, container_buf_size); - - //Verify container message using flatbuffer verifier - if (!VerifyContainerBuffer(container_verifier)) - { - LOG_DEBUG << "Flatbuffer verify: Bad peer message container."; - return -1; - } - - //Get message container - const Container *container = GetContainer(container_buf_ptr); - - //check protocol version of message whether it is greater than minimum supported protocol version. - const uint16_t version = container->version(); - if (version < util::MIN_PEERMSG_VERSION) - { - LOG_DEBUG << "Peer message is from unsupported protocol version (" << version << ")."; - return -1; - } - - //check message timestamp (ignore this for large messages). - if (container_buf_size <= MAX_SIZE_FOR_TIME_CHECK) - { - const uint64_t time_now = util::get_epoch_milliseconds(); - if (container->timestamp() < (time_now - conf::cfg.contract.roundtime * 4)) - { - LOG_DEBUG << "Peer message is too old."; - return -1; - } - } - - //Assign container and content out params. - *container_ref = container; - return 0; - } - - /** - * Validates the container message signing keys to see if the message is from a trusted source (UNL). - * @return 0 on successful verification. -1 for failure. - */ - int validate_container_trust(const Container *container) - { - std::string_view msg_pubkey = flatbuff_bytes_to_sv(container->pubkey()); - std::string_view msg_sig = flatbuff_bytes_to_sv(container->signature()); - - if (msg_pubkey.empty() || msg_sig.empty()) - { - LOG_DEBUG << "Peer message key pair incomplete. Trust verification failed."; - return -1; - } - - //validate if the message is not from a unl node. - if (!unl::exists(std::string(msg_pubkey))) - { - LOG_DEBUG << "Peer message pubkey verification failed. Not a UNL node."; - return -1; - } - - //verify message signature. - //this is performed towards end since this is bit expensive - std::string_view msg_content = flatbuff_bytes_to_sv(container->content()); - - if (crypto::verify(msg_content, msg_sig, msg_pubkey) != 0) - { - LOG_DEBUG << "Peer message signature verification failed."; - return -1; - } - - return 0; - } - - /** - * Verifies the Content message structure and outputs faltbuffer Content pointer to access the given buffer. - * - * @param content_ref A pointer reference to assign the pointer to the Content object. - * @param content_ptr Pointer to the buffer containing the data that should validated and interpreted - * via the container pointer. - * @param content_size Data buffer size. - * @return 0 on successful verification. -1 for failure. - */ - int validate_and_extract_content(const Content **content_ref, const uint8_t *content_ptr, const flatbuffers::uoffset_t content_size) - { - //Defining Flatbuffer verifier for message content verification. - //Since content is also serialised by using Flatbuffer we can verify it using Flatbuffer. - flatbuffers::Verifier content_verifier(content_ptr, content_size); - - //verify content message using flatbuffer verifier. - if (!VerifyContainerBuffer(content_verifier)) - { - LOG_DEBUG << "Flatbuffer verify: Bad content."; - return -1; - } - - *content_ref = GetContent(content_ptr); - return 0; - } - - //---Message reading helpers---/ - - /** - * Returns challenge from the peer challenge message. - * @param The Flatbuffer peer challenge message received from the peer. - * @return Peer challenge struct. - */ - const p2p::peer_challenge get_peer_challenge_from_msg(const Peer_Challenge_Message &msg) - { - return { - std::string(flatbuff_str_to_sv(msg.contract_id())), - msg.roundtime(), - std::string(flatbuff_str_to_sv(msg.challenge()))}; - } - - /** - * Creates a peer challenge response struct from the given peer challenge response message. - * @param The Flatbuffer peer challenge response message received from the peer. - * @return A peer challenge response struct representing the message. - */ - const p2p::peer_challenge_response create_peer_challenge_response_from_msg(const Peer_Challenge_Response_Message &msg, const flatbuffers::Vector *pubkey) - { - p2p::peer_challenge_response pchalresp; - - pchalresp.challenge = flatbuff_str_to_sv(msg.challenge()); - pchalresp.signature = flatbuff_bytes_to_sv(msg.sig()); - pchalresp.pubkey = flatbuff_bytes_to_sv(pubkey); - - return pchalresp; - } - - /** - * Creates a non-unl proposal stuct from the given non-unl proposal message. - * @param The Flatbuffer non-unl poporal received from the peer. - * @return A non-unl proposal struct representing the message. - */ - const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const NonUnl_Proposal_Message &msg, const uint64_t timestamp) - { - p2p::nonunl_proposal nup; - - if (msg.user_inputs()) - nup.user_inputs = flatbuf_user_input_group_to_user_input_map(msg.user_inputs()); - - return nup; - } - - /** - * Creates a proposal stuct from the given proposal message. - * @param msg The Flatbuffer poposal received from the peer. - * @return A proposal struct representing the message. - */ - const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector *pubkey, const uint64_t timestamp, const Sequence_Hash &last_primary_shard_id_msg) - { - p2p::proposal p; - - p.pubkey = flatbuff_bytes_to_sv(pubkey); - p.sent_timestamp = timestamp; - p.recv_timestamp = util::get_epoch_milliseconds(); - p.time = msg.time(); - p.roundtime = msg.roundtime(); - p.nonce = flatbuff_bytes_to_sv(msg.nonce()); - p.stage = msg.stage(); - p.state_hash = flatbuff_bytes_to_sv(msg.state_hash()); - p.patch_hash = flatbuff_bytes_to_sv(msg.patch_hash()); - - p2p::sequence_hash last_primary_shard_id; - last_primary_shard_id.seq_no = last_primary_shard_id_msg.shard_seq_no(); - last_primary_shard_id.hash = flatbuff_bytes_to_hash(last_primary_shard_id_msg.shard_hash()); - p.last_primary_shard_id = last_primary_shard_id; - - p2p::sequence_hash last_blob_shard_id; - const Sequence_Hash &last_blob_shard_id_msg = *msg.last_blob_shard_id(); - last_blob_shard_id.seq_no = last_blob_shard_id_msg.shard_seq_no(); - last_blob_shard_id.hash = flatbuff_bytes_to_hash(last_blob_shard_id_msg.shard_hash()); - p.last_blob_shard_id = last_blob_shard_id; - - if (msg.users()) - p.users = flatbuf_bytearrayvector_to_stringlist(msg.users()); - - if (msg.input_hashes()) - p.input_hashes = flatbuf_bytearrayvector_to_stringlist(msg.input_hashes()); - - if (msg.output_hash()) - p.output_hash = flatbuff_bytes_to_sv(msg.output_hash()); - - if (msg.output_sig()) - p.output_sig = flatbuff_bytes_to_sv(msg.output_sig()); - - return p; - } - - /** - * Creates a hpfs request struct from the given hpfs request message. - * @param msg Flatbuffer State request message received from the peer. - * @return A hpfs request struct representing the message. - */ - const p2p::hpfs_request create_hpfs_request_from_msg(const Hpfs_Request_Message &msg) - { - p2p::hpfs_request hr; - hr.mount_id = msg.mount_id(); - hr.block_id = msg.block_id(); - hr.is_file = msg.is_file(); - hr.parent_path = flatbuff_str_to_sv(msg.parent_path()); - hr.expected_hash = flatbuff_bytes_to_hash(msg.expected_hash()); - - return hr; - } - - /** - * Creates a peer property list from the given peer list response message. - * @param msg Flatbuffer Peer List response message received from the peer. - * @return A Peer list representing the message. - */ - const std::vector create_peer_list_response_from_msg(const Peer_List_Response_Message &msg) - { - return flatbuf_peer_propertieslist_to_peer_propertiesvector(msg.peer_list()); - } - - //---Message creation helpers---// - - /** - * Create peer challenge message from the given challenge. - * @param container_builder Flatbuffer builder for the container message. - * @param challenge Challenge message needed to convert to flatbuffer message. - */ - void create_msg_from_peer_challenge(flatbuffers::FlatBufferBuilder &container_builder, std::string &challenge) - { - flatbuffers::FlatBufferBuilder builder(1024); - - // We calculate the peer challenge to be a random string. - // Use libsodium to generate the random challenge bytes. - challenge.resize(PEERCHALLENGE_LEN); - randombytes_buf(challenge.data(), PEERCHALLENGE_LEN); - - const flatbuffers::Offset peer_challenge_msg = - CreatePeer_Challenge_Message( - builder, - sv_to_flatbuff_str(builder, conf::cfg.contract.id), - conf::cfg.contract.roundtime, - sv_to_flatbuff_str(builder, challenge)); - - const flatbuffers::Offset message = CreateContent(builder, Message_Peer_Challenge_Message, peer_challenge_msg.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message - create_containermsg_from_content(container_builder, builder, {}, false); - } - - /** - * Create peer challenge response message from the given challenge. - * @param container_builder Flatbuffer builder for the container message. - * @param challenge Message which need to be signed and placed in the container message. - */ - void create_peer_challenge_response_from_challenge(flatbuffers::FlatBufferBuilder &container_builder, const std::string &challenge) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset challenge_resp_msg = - CreatePeer_Challenge_Response_Message( - builder, - sv_to_flatbuff_str(builder, challenge), - sv_to_flatbuff_bytes(builder, crypto::sign(challenge, conf::cfg.node.private_key))); - - const flatbuffers::Offset message = CreateContent(builder, Message_Peer_Challenge_Response_Message, challenge_resp_msg.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, {}, true); - } - - void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::nonunl_proposal &nup) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset nupmsg = - CreateNonUnl_Proposal_Message( - builder, - user_input_map_to_flatbuf_user_input_group(builder, nup.user_inputs)); - - const flatbuffers::Offset message = CreateContent(builder, Message_NonUnl_Proposal_Message, nupmsg.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, {}, false); - } - - /** - * Create proposal peer message from the given proposal struct. - * @param container_builder Flatbuffer builder for the container message. - * @param p The proposal struct to be placed in the container message. - */ - void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p) - { - // todo:get a average propsal message size and allocate content builder based on that. - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset last_blob_shard_id_msg = CreateSequence_Hash( - builder, - p.last_blob_shard_id.seq_no, - hash_to_flatbuff_bytes(builder, p.last_blob_shard_id.hash)); - - const flatbuffers::Offset proposal = - CreateProposal_Message( - builder, - p.stage, - p.time, - p.roundtime, - sv_to_flatbuff_bytes(builder, p.nonce), - stringlist_to_flatbuf_bytearrayvector(builder, p.users), - stringlist_to_flatbuf_bytearrayvector(builder, p.input_hashes), - last_blob_shard_id_msg, - sv_to_flatbuff_bytes(builder, p.output_hash), - sv_to_flatbuff_bytes(builder, p.output_sig), - hash_to_flatbuff_bytes(builder, p.state_hash), - hash_to_flatbuff_bytes(builder, p.patch_hash)); - - const flatbuffers::Offset message = CreateContent(builder, Message_Proposal_Message, proposal.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, p.last_primary_shard_id, true); - } - - /** - * Ctreat npl message from the given npl output srtuct. - * @param container_builder Flatbuffer builder for the container message. - * @param msg The message to be sent as NPL message. - * @param last_primary_shard_id Last primary shard id. - */ - void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset npl = - CreateNpl_Message( - builder, - sv_to_flatbuff_bytes(builder, msg)); - - const flatbuffers::Offset message = CreateContent(builder, Message_Npl_Message, npl.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, true); - } - - /** - * Create hpfs request message from the given hpfs request struct. - * @param container_builder Flatbuffer builder for the container message. - * @param hr The hpfs request struct to be placed in the container message. - * @param last_primary_shard_id Last primary shard id. - */ - void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - flatbuffers::Offset srmsg = - CreateHpfs_Request_Message( - builder, - hr.mount_id, - sv_to_flatbuff_str(builder, hr.parent_path), - hr.is_file, - hr.block_id, - hash_to_flatbuff_bytes(builder, hr.expected_hash)); - - flatbuffers::Offset message = CreateContent(builder, Message_Hpfs_Request_Message, srmsg.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, false); - } - - /** - * Create content response message from the given content response. - * @param container_builder Flatbuffer builder for the container message. - * @param path The path of the directory. - * @param mount_id The mount id of the relavent hpfs mount. - * @param hash_nodes File or directory entries with hashes in the given parent path. - * @param expected_hash The exptected hash of the requested path. - * @param last_primary_shard_id Last primary shard id. - */ - void create_msg_from_fsentry_response( - flatbuffers::FlatBufferBuilder &container_builder, const std::string_view path, const uint32_t mount_id, - std::vector &hash_nodes, util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset resp = - CreateFs_Entry_Response( - builder, - hpfsfshashentry_to_flatbuff_hpfsfshashentry(builder, hash_nodes)); - - const flatbuffers::Offset st_resp = CreateHpfs_Response_Message( - builder, Hpfs_Response_Fs_Entry_Response, - resp.Union(), - hash_to_flatbuff_bytes(builder, expected_hash), - sv_to_flatbuff_str(builder, path), mount_id); - - flatbuffers::Offset message = CreateContent(builder, Message_Hpfs_Response_Message, st_resp.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, true); - } - - /** - * Create content response message from the given content response. - * @param container_builder Flatbuffer builder for the container message. - * @param path The path of the directory. - * @param mount_id The mount id of the relavent hpfs mount. - * @param hashmap Hashmap of the file - * @param last_primary_shard_id Last primary shard id. - */ - void create_msg_from_filehashmap_response( - flatbuffers::FlatBufferBuilder &container_builder, std::string_view path, const uint32_t mount_id, - std::vector &hashmap, std::size_t file_length, util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id) - { - // todo:get a average propsal message size and allocate content builder based on that. - flatbuffers::FlatBufferBuilder builder(1024); - - std::string_view hashmap_sv(reinterpret_cast(hashmap.data()), hashmap.size() * sizeof(util::h32)); - - const flatbuffers::Offset resp = - CreateFile_HashMap_Response( - builder, - file_length, - sv_to_flatbuff_bytes(builder, hashmap_sv)); - - const flatbuffers::Offset st_resp = CreateHpfs_Response_Message( - builder, - Hpfs_Response_File_HashMap_Response, - resp.Union(), - hash_to_flatbuff_bytes(builder, expected_hash), - sv_to_flatbuff_str(builder, path), mount_id); - - flatbuffers::Offset message = CreateContent(builder, Message_Hpfs_Response_Message, st_resp.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, true); - } - - /** - * Create content response message from the given content response. - * @param container_builder Flatbuffer builder for the container message. - * @param block_resp Block response struct to place in the message. - * @param mount_id The mount id of the relavent hpfs mount. - * @param last_primary_shard_id Last primary shard id. - */ - void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id, - const p2p::sequence_hash &last_primary_shard_id) - { - // todo:get a average propsal message size and allocate content builder based on that. - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset resp = - CreateBlock_Response( - builder, - block_resp.block_id, - sv_to_flatbuff_bytes(builder, block_resp.data)); - - const flatbuffers::Offset st_resp = CreateHpfs_Response_Message( - builder, - Hpfs_Response_Block_Response, - resp.Union(), - hash_to_flatbuff_bytes(builder, block_resp.hash), - sv_to_flatbuff_str(builder, block_resp.path), mount_id); - - flatbuffers::Offset message = CreateContent(builder, Message_Hpfs_Response_Message, st_resp.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - // we need to sign it and place it inside a container message. - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, true); - } - - /** - * Create connected status announcement message. - * @param container_builder Flatbuffer builder for the container message. - * @param need_consensus_msg_forwarding True if number of connections are below threshold and false otherwise. - */ - void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding, - const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset announcement = - CreatePeer_Requirement_Announcement_Message( - builder, - need_consensus_msg_forwarding); - - const flatbuffers::Offset message = CreateContent(builder, Message_Peer_Requirement_Announcement_Message, announcement.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, false); - } - - /** - * Create available capacity announcement message. - * @param container_builder Flatbuffer builder for the container message. - * @param available_capacity Number of incoming connection slots available, -1 means there's no limitation for connections. - * @param timestamp Announced timestamp. - */ - void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t ×tamp, - const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset announcement = - CreateAvailable_Capacity_Announcement_Message( - builder, - available_capacity, - timestamp); - - const flatbuffers::Offset message = CreateContent(builder, Message_Available_Capacity_Announcement_Message, announcement.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, false); - } - - /** - * Create peer list request message. - * @param container_builder Flatbuffer builder for the container message. - */ - void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset request = - CreatePeer_List_Request_Message( - builder); - - const flatbuffers::Offset message = CreateContent(builder, Message_Peer_List_Request_Message, request.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, false); - } - - /** - * Create peer list response message. - * @param container_builder Flatbuffer builder for the container message. - * @param peers Peer list to be sent to another peer. - * @param skipping_peer Peer that does not need to be sent. - */ - void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector &peers, const std::optional &skipping_ip_port, - const p2p::sequence_hash &last_primary_shard_id) - { - flatbuffers::FlatBufferBuilder builder(1024); - - const flatbuffers::Offset response = - CreatePeer_List_Response_Message( - builder, - peer_propertiesvector_to_flatbuf_peer_propertieslist(builder, peers, skipping_ip_port)); - - const flatbuffers::Offset message = CreateContent(builder, Message_Peer_List_Response_Message, response.Union()); - builder.Finish(message); // Finished building message content to get serialised content. - - // Now that we have built the content message, - create_containermsg_from_content(container_builder, builder, last_primary_shard_id, false); - } - - /** - * Creates a Flatbuffer container message from the given Content message. - * @param container_builder The Flatbuffer builder to which the final container message should be written to. - * @param content_builder The Flatbuffer builder containing the content message that should be placed - * inside the container message. - * @param sign Whether to sign the message content. - */ - void create_containermsg_from_content( - flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, const p2p::sequence_hash &last_primary_shard_id, const bool sign) - { - const uint8_t *content_buf = content_builder.GetBufferPointer(); - const flatbuffers::uoffset_t content_size = content_builder.GetSize(); - - // Create container message content from serialised content from previous step. - const flatbuffers::Offset> content = container_builder.CreateVector(content_buf, content_size); - - flatbuffers::Offset> pubkey_offset = 0; - flatbuffers::Offset> sig_offset = 0; - - if (sign) - { - // Sign message content with this node's private key. - std::string_view content_to_sign(reinterpret_cast(content_buf), content_size); - - sig_offset = sv_to_flatbuff_bytes(container_builder, crypto::sign(content_to_sign, conf::cfg.node.private_key)); - pubkey_offset = sv_to_flatbuff_bytes(container_builder, conf::cfg.node.public_key); - } - - const flatbuffers::Offset last_primary_shard_id_msg = CreateSequence_Hash( - container_builder, - last_primary_shard_id.seq_no, - hash_to_flatbuff_bytes(container_builder, last_primary_shard_id.hash)); - - const flatbuffers::Offset container_message = CreateContainer( - container_builder, - util::PEERMSG_VERSION, - util::get_epoch_milliseconds(), - pubkey_offset, - 0, - last_primary_shard_id_msg, - sig_offset, - content); - - // Finish building message container to get serialised message. - container_builder.Finish(container_message); - } - - //---Conversion helpers from flatbuffers data types to std data types---// - - const std::unordered_map> - flatbuf_user_input_group_to_user_input_map(const flatbuffers::Vector> *fbvec) - { - std::unordered_map> map; - map.reserve(fbvec->size()); - for (const UserInputGroup *group : *fbvec) - { - std::list user_inputs_list; - - for (const auto msg : *group->messages()) - { - user_inputs_list.push_back(usr::submitted_user_input{ - std::string(flatbuff_bytes_to_sv(msg->input_container())), - std::string(flatbuff_bytes_to_sv(msg->signature())), - static_cast(msg->protocol())}); - } - - map.emplace(flatbuff_bytes_to_sv(group->pubkey()), std::move(user_inputs_list)); - } - return map; - } - - //---Conversion helpers from std data types to flatbuffers data types---// - //---These are used in constructing Flatbuffer messages using builders---// - - const flatbuffers::Offset>> - user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map) - { - std::vector> fbvec; - fbvec.reserve(map.size()); - for (const auto &[pubkey, msglist] : map) - { - std::vector> fbmsgsvec; - for (const usr::submitted_user_input &msg : msglist) - { - fbmsgsvec.push_back(CreateUserInput( - builder, - sv_to_flatbuff_bytes(builder, msg.input_container), - sv_to_flatbuff_bytes(builder, msg.sig), - static_cast(msg.protocol))); - } - - fbvec.push_back(CreateUserInputGroup( - builder, - sv_to_flatbuff_bytes(builder, pubkey), - builder.CreateVector(fbmsgsvec))); - } - return builder.CreateVector(fbvec); - } - - void flatbuf_hpfsfshashentry_to_hpfsfshashentry(std::unordered_map &fs_entries, const flatbuffers::Vector> *fhashes) - { - for (const Hpfs_FS_Hash_Entry *f_hash : *fhashes) - { - p2p::hpfs_fs_hash_entry entry; - entry.name = flatbuff_str_to_sv(f_hash->name()); - entry.is_file = f_hash->is_file(); - entry.hash = flatbuff_bytes_to_hash(f_hash->hash()); - - fs_entries.emplace(entry.name, std::move(entry)); - } - } - - flatbuffers::Offset>> - hpfsfshashentry_to_flatbuff_hpfsfshashentry( - flatbuffers::FlatBufferBuilder &builder, - std::vector &hash_nodes) - { - std::vector> fbvec; - fbvec.reserve(hash_nodes.size()); - for (auto const &hash_node : hash_nodes) - { - flatbuffers::Offset hpfs_fs_entry = CreateHpfs_FS_Hash_Entry( - builder, - sv_to_flatbuff_str(builder, hash_node.name), - hash_node.is_file, - hash_to_flatbuff_bytes(builder, hash_node.hash)); - - fbvec.push_back(hpfs_fs_entry); - } - return builder.CreateVector(fbvec); - } - - /** - * Create peer list message from the given vector of peer properties structs. - * @param container_builder Flatbuffer builder for the container message. - * @param peers The Vector of peer properties to be placed in the container message. - * @param skipping_peer Peer that does not need to be sent. - */ - const flatbuffers::Offset>> - peer_propertiesvector_to_flatbuf_peer_propertieslist(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port) - { - std::vector> fbvec; - fbvec.reserve(peers.size()); - for (auto peer : peers) - { - // Skipping the requestedc peer from the peer list response. - if (!skipping_ip_port.has_value() || peer.ip_port != skipping_ip_port.value()) - fbvec.push_back(CreatePeer_Properties( - builder, - sv_to_flatbuff_str(builder, peer.ip_port.host_address), - peer.ip_port.port, - peer.available_capacity, - peer.timestamp)); - } - return builder.CreateVector(fbvec); - } - - /** - * Create vector of peer properties structs from the given peer list message. - * @param fbvec The peer list message to be convert to a list of peer properties structs. - */ - const std::vector - flatbuf_peer_propertieslist_to_peer_propertiesvector(const flatbuffers::Vector> *fbvec) - { - std::vector peers; - - for (const Peer_Properties *peer : *fbvec) - { - conf::peer_properties properties; - - properties.ip_port.host_address = flatbuff_str_to_sv(peer->host_address()); - properties.ip_port.port = peer->port(); - properties.timestamp = peer->timestamp(); - properties.available_capacity = peer->available_capacity(); - - peers.push_back(properties); - } - return peers; - } -} // namespace msg::fbuf::p2pmsg \ No newline at end of file diff --git a/src/msg/fbuf/p2pmsg_helpers.hpp b/src/msg/fbuf/p2pmsg_helpers.hpp deleted file mode 100644 index 2ef1d654..00000000 --- a/src/msg/fbuf/p2pmsg_helpers.hpp +++ /dev/null @@ -1,106 +0,0 @@ -#ifndef _HP_MSG_FBUF_P2PMSG_HELPERS_ -#define _HP_MSG_FBUF_P2PMSG_HELPERS_ - -#include "../../pchheader.hpp" -#include "../../p2p/p2p.hpp" -#include "../../util/h32.hpp" -#include "../../hpfs/hpfs_mount.hpp" -#include "p2pmsg_container_generated.h" -#include "p2pmsg_content_generated.h" - -namespace msg::fbuf::p2pmsg -{ - /** - * This section contains Flatbuffer p2p message reading/writing helpers. - */ - - //---Message validation helpers---/ - - int validate_and_extract_container(const Container **container_ref, std::string_view container_buf); - - int validate_container_trust(const Container *container); - - int validate_and_extract_content(const Content **content_ref, const uint8_t *content_ptr, const flatbuffers::uoffset_t content_size); - - //---Message reading helpers---/ - - const p2p::peer_challenge get_peer_challenge_from_msg(const Peer_Challenge_Message &msg); - - const p2p::peer_challenge_response create_peer_challenge_response_from_msg(const Peer_Challenge_Response_Message &msg, const flatbuffers::Vector *pubkey); - - const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const NonUnl_Proposal_Message &msg, const uint64_t timestamp); - - const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector *pubkey, const uint64_t timestamp, const Sequence_Hash &last_primary_shard_id_msg); - - const p2p::hpfs_request create_hpfs_request_from_msg(const Hpfs_Request_Message &msg); - - const std::vector create_peer_list_response_from_msg(const Peer_List_Response_Message &msg); - - //---Message creation helpers---// - void create_peer_challenge_response_from_challenge(flatbuffers::FlatBufferBuilder &container_builder, const std::string &challenge); - - void create_msg_from_peer_challenge(flatbuffers::FlatBufferBuilder &container_builder, std::string &challenge); - - void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::nonunl_proposal &nup); - - void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p); - - void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_fsentry_response( - flatbuffers::FlatBufferBuilder &container_builder, const std::string_view path, const uint32_t mount_id, - std::vector &hash_nodes, util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_filehashmap_response( - flatbuffers::FlatBufferBuilder &container_builder, std::string_view path, const uint32_t mount_id, - std::vector &hashmap, std::size_t file_length, util::h32 expected_hash, const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id, - const p2p::sequence_hash &last_primary_shard_id); - - void create_containermsg_from_content( - flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, const p2p::sequence_hash &last_primary_shard_id, const bool sign); - - void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding, - const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t ×tamp, - const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::sequence_hash &last_primary_shard_id); - - void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector &peers, const std::optional &skipping_ip_port, - const p2p::sequence_hash &last_primary_shard_id); - - //---Conversion helpers from flatbuffers data types to std data types---// - - const std::unordered_map> - flatbuf_user_input_group_to_user_input_map(const flatbuffers::Vector> *fbvec); - - //---Conversion helpers from std data types to flatbuffers data types---// - - const flatbuffers::Offset>> - user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map); - - const std::vector - flatbuf_peer_propertieslist_to_peer_propertiesvector(const flatbuffers::Vector> *fbvec); - - const flatbuffers::Offset>> - peer_propertiesvector_to_flatbuf_peer_propertieslist(flatbuffers::FlatBufferBuilder &builder, const std::vector &peers, const std::optional &skipping_ip_port); - - void flatbuf_hpfsfshashentry_to_hpfsfshashentry(std::unordered_map &fs_entries, - const flatbuffers::Vector> *fhashes); - - void hpfsfilehash_to_flatbuf_hpfsfilehash(flatbuffers::FlatBufferBuilder &builder, std::vector> &list, - std::string_view full_path, bool is_file, std::string_view hash); - - flatbuffers::Offset>> - hpfsfshashentry_to_flatbuff_hpfsfshashentry( - flatbuffers::FlatBufferBuilder &builder, - std::vector &hash_nodes); - -} // namespace msg::fbuf::p2pmsg - -#endif diff --git a/src/p2p/p2p.cpp b/src/p2p/p2p.cpp index 7b7b8b54..8637afb0 100644 --- a/src/p2p/p2p.cpp +++ b/src/p2p/p2p.cpp @@ -3,12 +3,15 @@ #include "../crypto.hpp" #include "../util/util.hpp" #include "../hplog.hpp" -#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/common_helpers.hpp" +#include "../msg/fbuf/p2pmsg_conversion.hpp" #include "../ledger/ledger.hpp" #include "p2p.hpp" #include "self_node.hpp" #include "../unl.hpp" +namespace p2pmsg = msg::fbuf::p2pmsg; + namespace p2p { @@ -170,10 +173,7 @@ namespace p2p */ void broadcast_message(const flatbuffers::FlatBufferBuilder &fbuf, const bool send_to_self, const bool is_msg_forwarding, const bool unl_only) { - std::string_view msg = std::string_view( - reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); - - broadcast_message(msg, send_to_self, is_msg_forwarding, unl_only); + broadcast_message(msg::fbuf::builder_to_string_view(fbuf), send_to_self, is_msg_forwarding, unl_only); } /** @@ -206,11 +206,11 @@ namespace p2p /** * Check whether the given message is qualified to be forwarded to peers. - * @param container The message container. - * @param content_message_type The message type. + * @param msg_type The message type. + * @param originated_on The originated epoch of the received message. * @return Returns true if the message is qualified for forwarding to peers. False otherwise. */ - bool validate_for_peer_msg_forwarding(const peer_comm_session &session, const msg::fbuf::p2pmsg::Container *container, const msg::fbuf::p2pmsg::Message &content_message_type) + bool validate_for_peer_msg_forwarding(const peer_comm_session &session, const enum msg::fbuf::p2pmsg::P2PMsgContent msg_type, const uint64_t originated_on) { // Checking whether the message forwarding is enabled. if (!conf::cfg.mesh.msg_forwarding) @@ -218,20 +218,22 @@ namespace p2p return false; } + // Only the selected types of messages are forwarded. + if (msg_type == p2pmsg::P2PMsgContent_ProposalMsg || + msg_type == p2pmsg::P2PMsgContent_NonUnlProposalMsg || + msg_type == p2pmsg::P2PMsgContent_NplMsg) + { + return true; + } + const uint64_t time_now = util::get_epoch_milliseconds(); - // Checking the time to live of the container. The time to live for forwarding is three times the round time. - if (container->timestamp() < (time_now - (conf::cfg.contract.roundtime * 3))) + // Checking the time to live of the message. The time to live for forwarding is three times the round time. + if (originated_on < (time_now - (conf::cfg.contract.roundtime * 3))) { LOG_DEBUG << "Peer message is too old for forwarding."; return false; } - // Only the selected types of messages are forwarded. - if (content_message_type == msg::fbuf::p2pmsg::Message_Proposal_Message || - content_message_type == msg::fbuf::p2pmsg::Message_NonUnl_Proposal_Message || - content_message_type == msg::fbuf::p2pmsg::Message_Npl_Message) - { - return true; - } + return false; } @@ -272,15 +274,51 @@ namespace p2p //send message to selected peer. peer_comm_session *session = it->second; - std::string_view msg = std::string_view( - reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); - - session->send(msg); + session->send(msg::fbuf::builder_to_string_view(fbuf)); target_pubkey = session->uniqueid; break; } } + /** + * Handle proposal message. This is called from peer and self message handlers. + */ + void handle_proposal_message(const p2p::proposal &p) + { + // Check the cap and insert proposal with lock. + std::scoped_lock lock(ctx.collected_msgs.proposals_mutex); + + // If max number of proposals reached skip the rest. + if (ctx.collected_msgs.proposals.size() == p2p::PROPOSAL_LIST_CAP) + LOG_DEBUG << "Proposal rejected. Maximum proposal count reached."; + else + ctx.collected_msgs.proposals.push_back(std::move(p)); + } + + /** + * Handle nonunl proposal message. This is called from peer and self message handlers. + */ + void handle_nonunl_proposal_message(const p2p::nonunl_proposal &nup) + { + // Check the cap and insert proposal with lock. + std::scoped_lock lock(ctx.collected_msgs.nonunl_proposals_mutex); + + // If max number of nonunl proposals reached skip the rest. + if (ctx.collected_msgs.nonunl_proposals.size() == p2p::NONUNL_PROPOSAL_LIST_CAP) + LOG_DEBUG << "Nonunl proposal rejected. Maximum nonunl proposal count reached. self"; + else + ctx.collected_msgs.nonunl_proposals.push_back(std::move(nup)); + } + + /** + * Handle npl message. This is called from peer and self message handlers. + */ + void handle_npl_message(const p2p::npl_message &npl) + { + if (!consensus::push_npl_message(npl)) + LOG_DEBUG << "NPL message from self enqueue failure."; + } + /** * Sends the peer requirement to the given peer session. If a session is not given, broadcast to all the connected peers. * @param need_consensus_msg_forwarding True if the number of connections are below the threshold value. @@ -288,18 +326,12 @@ namespace p2p */ void send_peer_requirement_announcement(const bool need_consensus_msg_forwarding, peer_comm_session *session) { - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_peer_requirement_announcement(fbuf, need_consensus_msg_forwarding, ledger::ctx.get_last_primary_shard_id()); + flatbuffers::FlatBufferBuilder fbuf; + p2pmsg::create_msg_from_peer_requirement_announcement(fbuf, need_consensus_msg_forwarding); if (session) - { - std::string_view msg = std::string_view( - reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); - session->send(msg); - } + session->send(msg::fbuf::builder_to_string_view(fbuf)); else - { broadcast_message(fbuf, false); - } } /** @@ -309,8 +341,8 @@ namespace p2p void send_available_capacity_announcement(const int16_t &available_capacity) { const uint64_t time_now = util::get_epoch_milliseconds(); - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_available_capacity_announcement(fbuf, available_capacity, time_now, ledger::ctx.get_last_primary_shard_id()); + flatbuffers::FlatBufferBuilder fbuf; + p2pmsg::create_msg_from_available_capacity_announcement(fbuf, available_capacity, time_now); broadcast_message(fbuf, false); } @@ -320,11 +352,9 @@ namespace p2p */ void send_known_peer_list(peer_comm_session *session) { - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_peer_list_response(fbuf, ctx.server->req_known_remotes, session->known_ipport, ledger::ctx.get_last_primary_shard_id()); - std::string_view msg = std::string_view( - reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); - session->send(msg); + flatbuffers::FlatBufferBuilder fbuf; + p2pmsg::create_msg_from_peer_list_response(fbuf, ctx.server->req_known_remotes, session->known_ipport); + session->send(msg::fbuf::builder_to_string_view(fbuf)); } /** @@ -354,8 +384,8 @@ namespace p2p */ void send_peer_list_request() { - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_peer_list_request(fbuf, ledger::ctx.get_last_primary_shard_id()); + flatbuffers::FlatBufferBuilder fbuf; + p2pmsg::create_msg_from_peer_list_request(fbuf); std::string target_pubkey; send_message_to_random_peer(fbuf, target_pubkey); LOG_DEBUG << "Peer list request: Requesting from [" << target_pubkey.substr(0, 10) << "]"; diff --git a/src/p2p/p2p.hpp b/src/p2p/p2p.hpp index 142f68a3..43ef3462 100644 --- a/src/p2p/p2p.hpp +++ b/src/p2p/p2p.hpp @@ -5,7 +5,7 @@ #include "../usr/user_input.hpp" #include "../util/h32.hpp" #include "../conf.hpp" -#include "../msg/fbuf/p2pmsg_container_generated.h" +#include "../msg/fbuf/p2pmsg_generated.h" #include "peer_comm_server.hpp" #include "peer_comm_session.hpp" #include "peer_session_handler.hpp" @@ -85,18 +85,22 @@ namespace p2p std::string pubkey; }; - enum LEDGER_RESPONSE_ERROR + struct peer_capacity_announcement { - NONE = 0, - INVALID_MIN_LEDGER = 1, - REQ_LEDGER_NOT_FOUND = 2 + int16_t available_capacity = 0; + uint64_t timestamp = 0; + }; + + struct peer_requirement_announcement + { + bool need_consensus_msg_forwarding = false; }; // Represents an NPL message sent by a peer. struct npl_message { - std::string pubkey; // Peer binary pubkey. - p2p::sequence_hash last_primary_shard_id; // Last primary shard of the peer. + std::string pubkey; // Peer binary pubkey. + p2p::sequence_hash lcl_id; // lcl of the peer. std::string data; }; @@ -127,6 +131,13 @@ namespace p2p util::h32 hash; // Hash of the bloc data. }; + struct peer_message_info + { + const msg::fbuf::p2pmsg::P2PMsg *p2p_msg = NULL; + const enum msg::fbuf::p2pmsg::P2PMsgContent type = msg::fbuf::p2pmsg::P2PMsgContent_NONE; + const uint64_t originated_on = 0; + }; + struct message_collection { std::list proposals; @@ -183,7 +194,13 @@ namespace p2p void send_message_to_random_peer(const flatbuffers::FlatBufferBuilder &fbuf, std::string &target_pubkey); - bool validate_for_peer_msg_forwarding(const peer_comm_session &session, const msg::fbuf::p2pmsg::Container *container, const msg::fbuf::p2pmsg::Message &content_message_type); + void handle_proposal_message(const p2p::proposal &p); + + void handle_nonunl_proposal_message(const p2p::nonunl_proposal &nup); + + void handle_npl_message(const p2p::npl_message &npl); + + bool validate_for_peer_msg_forwarding(const peer_comm_session &session, const enum msg::fbuf::p2pmsg::P2PMsgContent msg_type, const uint64_t originated_on); void send_peer_requirement_announcement(const bool need_consensus_msg_forwarding, peer_comm_session *session = NULL); diff --git a/src/p2p/peer_comm_server.cpp b/src/p2p/peer_comm_server.cpp index 8f4ff168..b3f5f8be 100644 --- a/src/p2p/peer_comm_server.cpp +++ b/src/p2p/peer_comm_server.cpp @@ -1,6 +1,5 @@ #include "../comm/comm_server.hpp" #include "../util/util.hpp" -#include "../msg/fbuf/p2pmsg_helpers.hpp" #include "../ledger/ledger.hpp" #include "../unl.hpp" #include "../conf.hpp" diff --git a/src/p2p/peer_session_handler.cpp b/src/p2p/peer_session_handler.cpp index d578a1d1..e9760463 100644 --- a/src/p2p/peer_session_handler.cpp +++ b/src/p2p/peer_session_handler.cpp @@ -5,9 +5,8 @@ #include "../util/util.hpp" #include "../util/rollover_hashset.hpp" #include "../hplog.hpp" -#include "../msg/fbuf/p2pmsg_container_generated.h" -#include "../msg/fbuf/p2pmsg_content_generated.h" -#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/p2pmsg_generated.h" +#include "../msg/fbuf/p2pmsg_conversion.hpp" #include "../msg/fbuf/common_helpers.hpp" #include "../ledger/ledger.hpp" #include "peer_comm_session.hpp" @@ -36,7 +35,7 @@ namespace p2p } // Send peer challenge. - flatbuffers::FlatBufferBuilder fbuf(1024); + flatbuffers::FlatBufferBuilder fbuf; p2pmsg::create_msg_from_peer_challenge(fbuf, session.issued_challenge); std::string_view msg = std::string_view( reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); @@ -54,37 +53,35 @@ namespace p2p // Adding message size to peer message characters(bytes) per minute counter. session.increment_metric(comm::SESSION_THRESHOLDS::MAX_RAWBYTES_PER_MINUTE, message.size()); - const p2pmsg::Container *container; - if (p2pmsg::validate_and_extract_container(&container, message) != 0) + if (!p2pmsg::verify_peer_message(message)) + { + session.increment_metric(comm::SESSION_THRESHOLDS::MAX_BADMSGS_PER_MINUTE, 1); + LOG_DEBUG << "Flatbuffer verify: Bad peer message."; return 0; + } - //Get serialised message content. - const flatbuffers::Vector *container_content = container->content(); + const peer_message_info mi = p2pmsg::get_peer_message_info(message); - //Accessing message content and size. - const uint8_t *content_ptr = container_content->Data(); - const flatbuffers::uoffset_t content_size = container_content->size(); - - const p2pmsg::Content *content; - if (p2pmsg::validate_and_extract_content(&content, content_ptr, content_size) != 0) + if (mi.type == p2pmsg::P2PMsgContent_NONE) + { + session.increment_metric(comm::SESSION_THRESHOLDS::MAX_BADMSGS_PER_MINUTE, 1); + LOG_DEBUG << "Received invalid peer message type. " << session.display_name(); return 0; - - if (!recent_peermsg_hashes.try_emplace(crypto::get_hash(message))) + } + else if (!recent_peermsg_hashes.try_emplace(crypto::get_hash(message))) { session.increment_metric(comm::SESSION_THRESHOLDS::MAX_DUPMSGS_PER_MINUTE, 1); LOG_DEBUG << "Duplicate peer message. " << session.display_name(); return 0; } - const p2pmsg::Message content_message_type = content->message_type(); //i.e - proposal, npl, state request, state response, etc - // Check whether the message is qualified for message forwarding. - if (p2p::validate_for_peer_msg_forwarding(session, container, content_message_type)) + if (p2p::validate_for_peer_msg_forwarding(session, mi.type, mi.originated_on)) { // Npl messages and consensus proposals are forwarded only to unl nodes if relavent flags (npl and consensus) are set to private. // If consensus and npl flags are public, these messages are forward to all the connected nodes. - const bool unl_only = (!conf::cfg.contract.is_npl_public && content_message_type == p2pmsg::Message_Npl_Message) || - (!conf::cfg.contract.is_consensus_public && content_message_type == p2pmsg::Message_Proposal_Message); + const bool unl_only = (!conf::cfg.contract.is_npl_public && mi.type == p2pmsg::P2PMsgContent_NplMsg) || + (!conf::cfg.contract.is_consensus_public && mi.type == p2pmsg::P2PMsgContent_ProposalMsg); if (session.need_consensus_msg_forwarding) { // Forward messages received by weakly connected nodes to other peers. @@ -97,9 +94,9 @@ namespace p2p } } - if (content_message_type == p2pmsg::Message_Peer_Challenge_Message) // message is a peer challenge announcement + if (mi.type == p2pmsg::P2PMsgContent_PeerChallengeMsg) { - const p2p::peer_challenge chall = p2pmsg::get_peer_challenge_from_msg(*content->message_as_Peer_Challenge_Message()); + const p2p::peer_challenge chall = p2pmsg::create_peer_challenge_from_msg(mi); // Check whether contract ids match. if (chall.contract_id != conf::cfg.contract.id) @@ -112,20 +109,15 @@ namespace p2p session.reported_roundtime = chall.roundtime; // Sending the challenge response to the sender. - flatbuffers::FlatBufferBuilder fbuf(1024); + flatbuffers::FlatBufferBuilder fbuf; p2pmsg::create_peer_challenge_response_from_challenge(fbuf, chall.challenge); - std::string_view msg = std::string_view( - reinterpret_cast(fbuf.GetBufferPointer()), fbuf.GetSize()); - return session.send(msg); + return session.send(msg::fbuf::builder_to_string_view(fbuf)); } - else if (content_message_type == p2pmsg::Message_Peer_Challenge_Response_Message) // message is a peer challenge response + else if (mi.type == p2pmsg::P2PMsgContent_PeerChallengeResponseMsg) { // Ignore if challenge is already resolved. if (session.challenge_status == comm::CHALLENGE_ISSUED) - { - const p2p::peer_challenge_response challenge_resp = p2pmsg::create_peer_challenge_response_from_msg(*content->message_as_Peer_Challenge_Response_Message(), container->pubkey()); - return p2p::resolve_peer_challenge(session, challenge_resp); - } + return p2p::resolve_peer_challenge(session, p2pmsg::create_peer_challenge_response_from_msg(mi)); } if (session.challenge_status != comm::CHALLENGE_VERIFIED) @@ -134,64 +126,57 @@ namespace p2p return 0; } - if (content_message_type == p2pmsg::Message_Peer_List_Response_Message) // This message is the peer list response message. + if (mi.type == p2pmsg::P2PMsgContent_PeerListResponseMsg) { - p2p::merge_peer_list(p2pmsg::create_peer_list_response_from_msg(*content->message_as_Peer_List_Response_Message())); + p2p::merge_peer_list(p2pmsg::create_peer_list_response_from_msg(mi)); } - else if (content_message_type == p2pmsg::Message_Peer_List_Request_Message) // This message is the peer list request message. + else if (mi.type == p2pmsg::P2PMsgContent_PeerListRequestMsg) { p2p::send_known_peer_list(&session); } - else if (content_message_type == p2pmsg::Message_Available_Capacity_Announcement_Message) // This message is the available capacity announcement message. + else if (mi.type == p2pmsg::P2PMsgContent_PeerCapacityAnnouncementMsg) { if (session.known_ipport.has_value()) { - const p2pmsg::Available_Capacity_Announcement_Message *announcement_msg = content->message_as_Available_Capacity_Announcement_Message(); - p2p::update_known_peer_available_capacity(session.known_ipport.value(), announcement_msg->available_capacity(), announcement_msg->timestamp()); + const p2p::peer_capacity_announcement ann = p2pmsg::create_peer_capacity_announcement_from_msg(mi); + p2p::update_known_peer_available_capacity(session.known_ipport.value(), ann.available_capacity, ann.timestamp); } } - else if (content_message_type == p2pmsg::Message_Peer_Requirement_Announcement_Message) // This message is a peer requirement announcement message. + else if (mi.type == p2pmsg::P2PMsgContent_PeerRequirementAnnouncementMsg) { - const p2pmsg::Peer_Requirement_Announcement_Message *announcement_msg = content->message_as_Peer_Requirement_Announcement_Message(); - session.need_consensus_msg_forwarding = announcement_msg->need_consensus_msg_forwarding(); - if (session.need_consensus_msg_forwarding) - LOG_DEBUG << "Consensus message forwaring is required for " << session.display_name(); - else - LOG_DEBUG << "Consensus message forwaring is not required for " << session.display_name(); + const p2p::peer_requirement_announcement ann = p2pmsg::create_peer_requirement_announcement_from_msg(mi); + session.need_consensus_msg_forwarding = ann.need_consensus_msg_forwarding; + LOG_DEBUG << "Peer requirement: " << session.display_name() << " consensus msg forwarding:" << ann.need_consensus_msg_forwarding; } - else if (content_message_type == p2pmsg::Message_Proposal_Message) // message is a proposal message + else if (mi.type == p2pmsg::P2PMsgContent_NonUnlProposalMsg) { - // We only trust proposals coming from UNL peers. - if (p2pmsg::validate_container_trust(container) != 0) + handle_nonunl_proposal_message(p2pmsg::create_nonunl_proposal_from_msg(mi)); + } + else if (mi.type == p2pmsg::P2PMsgContent_ProposalMsg) + { + if (!p2pmsg::verify_proposal_msg_signature(mi)) { session.increment_metric(comm::SESSION_THRESHOLDS::MAX_BADSIGMSGS_PER_MINUTE, 1); LOG_DEBUG << "Proposal rejected due to trust failure. " << session.display_name(); return 0; } - if (handle_proposal_message(container, content) != 0) - LOG_DEBUG << "Proposal rejected. Maximum proposal count reached. " << session.display_name(); + handle_proposal_message(p2pmsg::create_proposal_from_msg(mi)); } - else if (content_message_type == p2pmsg::Message_NonUnl_Proposal_Message) //message is a non-unl proposal message + else if (mi.type == p2pmsg::P2PMsgContent_NplMsg) { - if (handle_nonunl_proposal_message(container, content) != 0) - LOG_DEBUG << "Nonunl proposal rejected. Maximum nonunl proposal count reached. " << session.display_name(); - } - else if (content_message_type == p2pmsg::Message_Npl_Message) //message is a NPL message - { - if (p2pmsg::validate_container_trust(container) != 0) + if (!p2pmsg::verify_npl_msg_signature(mi)) { session.increment_metric(comm::SESSION_THRESHOLDS::MAX_BADSIGMSGS_PER_MINUTE, 1); - LOG_DEBUG << "NPL message rejected due to trust failure. " << session.display_name(); + LOG_DEBUG << "Npl message rejected due to trust failure. " << session.display_name(); return 0; } - handle_npl_message(container, content); + handle_npl_message(p2pmsg::create_npl_from_msg(mi)); } - else if (content_message_type == p2pmsg::Message_Hpfs_Request_Message) + else if (mi.type == p2pmsg::P2PMsgContent_HpfsRequestMsg) { - const msg::fbuf::p2pmsg::Content *content = msg::fbuf::p2pmsg::GetContent(content_ptr); - const p2p::hpfs_request hr = p2pmsg::create_hpfs_request_from_msg(*content->message_as_Hpfs_Request_Message()); + const p2p::hpfs_request hr = p2pmsg::create_hpfs_request_from_msg(mi); if (hr.mount_id == sc::contract_fs.mount_id) { // Check the cap and insert request with lock. @@ -199,13 +184,9 @@ namespace p2p // If max number of state requests reached skip the rest. if (ctx.collected_msgs.contract_hpfs_requests.size() < p2p::HPFS_REQ_LIST_CAP) - { ctx.collected_msgs.contract_hpfs_requests.push_back(std::make_pair(session.pubkey, std::move(hr))); - } else - { LOG_DEBUG << "Hpfs contract fs request rejected. Maximum hpfs contract fs request count reached. " << session.display_name(); - } } else if (hr.mount_id == ledger::ledger_fs.mount_id) { @@ -214,52 +195,37 @@ namespace p2p // If max number of state requests reached skip the rest. if (ctx.collected_msgs.ledger_hpfs_requests.size() < p2p::HPFS_REQ_LIST_CAP) - { ctx.collected_msgs.ledger_hpfs_requests.push_back(std::make_pair(session.pubkey, std::move(hr))); - } else - { LOG_DEBUG << "Hpfs ledger fs request rejected. Maximum hpfs ledger fs request count reached. " << session.display_name(); - } } } - else if (content_message_type == p2pmsg::Message_Hpfs_Response_Message) + else if (mi.type == p2pmsg::P2PMsgContent_HpfsResponseMsg) { - const msg::fbuf::p2pmsg::Content *content = msg::fbuf::p2pmsg::GetContent(content_ptr); - const msg::fbuf::p2pmsg::Hpfs_Response_Message *resp_msg = content->message_as_Hpfs_Response_Message(); + const p2pmsg::HpfsResponseMsg &resp_msg = *mi.p2p_msg->content_as_HpfsResponseMsg(); // Only accept hpfs responses if hpfs fs is syncing. - if (sc::contract_sync_worker.is_syncing && resp_msg->mount_id() == sc::contract_fs.mount_id) + if (sc::contract_sync_worker.is_syncing && resp_msg.mount_id() == sc::contract_fs.mount_id) { // Check the cap and insert state_response with lock. std::scoped_lock lock(ctx.collected_msgs.contract_hpfs_responses_mutex); // If max number of state responses reached skip the rest. if (ctx.collected_msgs.contract_hpfs_responses.size() < p2p::HPFS_RES_LIST_CAP) - { - std::string response(reinterpret_cast(content_ptr), content_size); - ctx.collected_msgs.contract_hpfs_responses.push_back(std::make_pair(session.uniqueid, std::move(response))); - } + ctx.collected_msgs.contract_hpfs_responses.push_back(std::make_pair(session.uniqueid, std::string(message))); else - { - LOG_DEBUG << "Contract hpfs response rejected. Maximum contract hpfs response count reached. " << session.display_name(); - } + LOG_DEBUG << "Contract hpfs response rejected. Maximum response count reached. " << session.display_name(); } - else if (ledger::ledger_sync_worker.is_syncing && resp_msg->mount_id() == ledger::ledger_fs.mount_id) + else if (ledger::ledger_sync_worker.is_syncing && resp_msg.mount_id() == ledger::ledger_fs.mount_id) { // Check the cap and insert state_response with lock. std::scoped_lock lock(ctx.collected_msgs.ledger_hpfs_responses_mutex); // If max number of state responses reached skip the rest. if (ctx.collected_msgs.ledger_hpfs_responses.size() < p2p::HPFS_RES_LIST_CAP) - { - std::string response(reinterpret_cast(content_ptr), content_size); - ctx.collected_msgs.ledger_hpfs_responses.push_back(std::make_pair(session.uniqueid, std::move(response))); - } + ctx.collected_msgs.ledger_hpfs_responses.push_back(std::make_pair(session.uniqueid, std::string(message))); else - { - LOG_DEBUG << "Ledger hpfs response rejected. Maximum ledger hpfs response count reached. " << session.display_name(); - } + LOG_DEBUG << "Ledger hpfs response rejected. Maximum response count reached. " << session.display_name(); } } else @@ -275,96 +241,18 @@ namespace p2p */ int handle_self_message(std::string_view message) { - const p2pmsg::Container *container; - if (p2pmsg::validate_and_extract_container(&container, message) != 0) - return 0; + const peer_message_info mi = p2pmsg::get_peer_message_info(message); - //Get serialised message content. - const flatbuffers::Vector *container_content = container->content(); - - //Accessing message content and size. - const uint8_t *content_ptr = container_content->Data(); - const flatbuffers::uoffset_t content_size = container_content->size(); - - const p2pmsg::Content *content; - if (p2pmsg::validate_and_extract_content(&content, content_ptr, content_size) != 0) - return 0; - - const p2pmsg::Message content_message_type = content->message_type(); //i.e - proposal, npl, state request, state response, etc - - if (content_message_type == p2pmsg::Message_Proposal_Message) // message is a proposal message - { - if (handle_proposal_message(container, content) != 0) - LOG_DEBUG << "Proposal rejected. Maximum proposal count reached. self"; - } - else if (content_message_type == p2pmsg::Message_NonUnl_Proposal_Message) //message is a non-unl proposal message - { - if (handle_nonunl_proposal_message(container, content) != 0) - LOG_DEBUG << "Nonunl proposal rejected. Maximum nonunl proposal count reached. self"; - } - else if (content_message_type == p2pmsg::Message_Npl_Message) //message is a NPL message - handle_npl_message(container, content); + if (mi.type == p2pmsg::P2PMsgContent_ProposalMsg) + handle_proposal_message(p2pmsg::create_proposal_from_msg(mi)); + else if (mi.type == p2pmsg::P2PMsgContent_NonUnlProposalMsg) + handle_nonunl_proposal_message(p2pmsg::create_nonunl_proposal_from_msg(mi)); + else if (mi.type == p2pmsg::P2PMsgContent_NplMsg) + handle_npl_message(p2pmsg::create_npl_from_msg(mi)); return 0; } - /** - * Handle proposal message. - * @param container Message container. - * @param content Message content. - * @return returns 0 if proposal is pushed to the list, otherwise -1. - */ - int handle_proposal_message(const p2pmsg::Container *container, const p2pmsg::Content *content) - { - // Check the cap and insert proposal with lock. - std::scoped_lock lock(ctx.collected_msgs.proposals_mutex); - - // If max number of proposals reached skip the rest. - if (ctx.collected_msgs.proposals.size() == p2p::PROPOSAL_LIST_CAP) - return -1; - - ctx.collected_msgs.proposals.push_back( - p2pmsg::create_proposal_from_msg(*content->message_as_Proposal_Message(), container->pubkey(), container->timestamp(), *container->last_primary_shard_id())); - - return 0; - } - - /** - * Handle nonunl proposal message. - * @param container Message container. - * @param content Message content. - * @return returns 0 if nonunl proposal is pushed to the list, otherwise -1. - */ - int handle_nonunl_proposal_message(const p2pmsg::Container *container, const p2pmsg::Content *content) - { - // Check the cap and insert proposal with lock. - std::scoped_lock lock(ctx.collected_msgs.nonunl_proposals_mutex); - - // If max number of nonunl proposals reached skip the rest. - if (ctx.collected_msgs.nonunl_proposals.size() == p2p::NONUNL_PROPOSAL_LIST_CAP) - return -1; - - ctx.collected_msgs.nonunl_proposals.push_back( - p2pmsg::create_nonunl_proposal_from_msg(*content->message_as_NonUnl_Proposal_Message(), container->timestamp())); - - return 0; - } - - void handle_npl_message(const p2pmsg::Container *container, const p2pmsg::Content *content) - { - const p2pmsg::Npl_Message *npl_p2p_msg = content->message_as_Npl_Message(); - npl_message msg; - msg.data = msg::fbuf::flatbuff_bytes_to_sv(npl_p2p_msg->data()); - msg.pubkey = msg::fbuf::flatbuff_bytes_to_sv(container->pubkey()); - msg.last_primary_shard_id.seq_no = container->last_primary_shard_id()->shard_seq_no(); - msg.last_primary_shard_id.hash = msg::fbuf::flatbuff_bytes_to_hash(container->last_primary_shard_id()->shard_hash()); - - if (!consensus::push_npl_message(msg)) - { - LOG_DEBUG << "NPL message from self enqueue failure."; - } - } - //peer session on message callback method int handle_peer_close(const p2p::peer_comm_session &session) { diff --git a/src/p2p/peer_session_handler.hpp b/src/p2p/peer_session_handler.hpp index 69828f19..6a1c4b5a 100644 --- a/src/p2p/peer_session_handler.hpp +++ b/src/p2p/peer_session_handler.hpp @@ -2,22 +2,15 @@ #define _HP_P2P_PEER_SESSION_HANDLER_ #include "../pchheader.hpp" -#include "../msg/fbuf/p2pmsg_container_generated.h" -#include "../msg/fbuf/p2pmsg_content_generated.h" #include "peer_comm_session.hpp" -namespace p2pmsg = msg::fbuf::p2pmsg; - namespace p2p { int handle_peer_connect(p2p::peer_comm_session &session); int handle_peer_message(p2p::peer_comm_session &session, std::string_view message); int handle_self_message(std::string_view message); int handle_peer_close(const p2p::peer_comm_session &session); - int handle_proposal_message(const p2pmsg::Container *container, const p2pmsg::Content *content); - int handle_nonunl_proposal_message(const p2pmsg::Container *container, const p2pmsg::Content *content); void handle_peer_on_verified(p2p::peer_comm_session &session); - void handle_npl_message(const p2pmsg::Container *container, const p2pmsg::Content *content); } // namespace p2p #endif \ No newline at end of file diff --git a/src/sc/sc.cpp b/src/sc/sc.cpp index b63175dc..c48f59ad 100644 --- a/src/sc/sc.cpp +++ b/src/sc/sc.cpp @@ -3,7 +3,7 @@ #include "../consensus.hpp" #include "../hplog.hpp" #include "../ledger/ledger.hpp" -#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/p2pmsg_conversion.hpp" #include "../msg/controlmsg_common.hpp" #include "../msg/controlmsg_parser.hpp" #include "../unl.hpp" @@ -553,7 +553,7 @@ namespace sc p2p::npl_message npl_msg; if (ctx.args.npl_messages.try_dequeue(npl_msg)) { - if (npl_msg.last_primary_shard_id == ctx.args.lasl_primary_shard_id) + if (npl_msg.lcl_id == ctx.args.lcl_id) { const std::string pubkeyhex = util::to_hex(npl_msg.pubkey); @@ -650,8 +650,8 @@ namespace sc if (!output.empty()) { - flatbuffers::FlatBufferBuilder fbuf(1024); - msg::fbuf::p2pmsg::create_msg_from_npl_output(fbuf, output, ledger::ctx.get_last_primary_shard_id()); + flatbuffers::FlatBufferBuilder fbuf; + msg::fbuf::p2pmsg::create_msg_from_npl_output(fbuf, output, ledger::ctx.get_lcl_id()); p2p::broadcast_message(fbuf, true, false, !conf::cfg.contract.is_npl_public); } } diff --git a/src/sc/sc.hpp b/src/sc/sc.hpp index 5ff484b9..f020ca4b 100644 --- a/src/sc/sc.hpp +++ b/src/sc/sc.hpp @@ -85,9 +85,6 @@ namespace sc // Current HotPocket lcl (seq no. and ledger hash hex) p2p::sequence_hash lcl_id; - // Current HotPocket primary shard id (struct of seq no. and ledger hash) - p2p::sequence_hash lasl_primary_shard_id; - // State hash after execution will be copied to this (not applicable to read only mode). util::h32 post_execution_state_hash = util::h32_empty; diff --git a/src/util/util.cpp b/src/util/util.cpp index 3ff92398..ac3e8863 100644 --- a/src/util/util.cpp +++ b/src/util/util.cpp @@ -411,11 +411,34 @@ namespace util return fcntl(fd, F_SETLKW, &lock); } - /** - * Convert given little endian byte stream to uint64_t. - * @param data Byte stream to be converted. - * @return Returns converted uint64_t. - */ + void uint32_to_bytes(uint8_t *dest, const uint32_t x) + { + dest[0] = (uint8_t)((x >> 24) & 0xff); + dest[1] = (uint8_t)((x >> 16) & 0xff); + dest[2] = (uint8_t)((x >> 8) & 0xff); + dest[3] = (uint8_t)((x >> 0) & 0xff); + } + + uint32_t uint32_from_bytes(const uint8_t *data) + { + return ((uint32_t)data[0] << 24) + + ((uint32_t)data[1] << 16) + + ((uint32_t)data[2] << 8) + + ((uint32_t)data[3]); + } + + void uint64_to_bytes(uint8_t *dest, const uint64_t x) + { + dest[0] = (uint8_t)((x >> 56) & 0xff); + dest[1] = (uint8_t)((x >> 48) & 0xff); + dest[2] = (uint8_t)((x >> 40) & 0xff); + dest[3] = (uint8_t)((x >> 32) & 0xff); + dest[4] = (uint8_t)((x >> 24) & 0xff); + dest[5] = (uint8_t)((x >> 16) & 0xff); + dest[6] = (uint8_t)((x >> 8) & 0xff); + dest[7] = (uint8_t)((x >> 0) & 0xff); + } + uint64_t uint64_from_bytes(const uint8_t *data) { return ((uint64_t)data[0] << 56) + @@ -428,17 +451,4 @@ namespace util ((uint64_t)data[7]); } - /** - * Convert given uint64_t to little endian byte stream. - * @param dest Byte stream to be populated. - * @param x uint64_t to be converted. - */ - void uint64_to_bytes(uint8_t *dest, uint64_t x) - { - for (int j = 0; j < 8; j++) - { - *(dest + (7 - j)) = x & 0xff; - x >>= 8; - } - } } // namespace util diff --git a/src/util/util.hpp b/src/util/util.hpp index a7a2d3f6..3bd195c2 100644 --- a/src/util/util.hpp +++ b/src/util/util.hpp @@ -18,17 +18,6 @@ namespace util // Minimum compatible config version (this will be used to validate configs) constexpr const char *MIN_CONFIG_VERSION = "0.1"; - // Current version of the peer message protocol. - constexpr uint8_t PEERMSG_VERSION = 1; - - // Minimum compatible peer message version (this will be used to accept/reject incoming peer connections) - // (Keeping this as int for effcient msg payload and comparison) - constexpr uint8_t MIN_PEERMSG_VERSION = 1; - - // Minimum compatible npl contract input version (this will be used to generate the npl input to feed the contract) - // (Keeping this as int for effcient msg payload and comparison) - constexpr uint8_t MIN_NPL_INPUT_VERSION = 1; - /** * The messaging protocol used in a web socket channel. */ @@ -86,9 +75,11 @@ namespace util int release_lock(const int fd, struct flock &lock); + void uint32_to_bytes(uint8_t *dest, const uint32_t x); + uint32_t uint32_from_bytes(const uint8_t *data); + void uint64_to_bytes(uint8_t *dest, const uint64_t x); uint64_t uint64_from_bytes(const uint8_t *data); - void uint64_to_bytes(uint8_t *dest, const uint64_t x); } // namespace util #endif