diff --git a/CMakeLists.txt b/CMakeLists.txt index 8f8ac6f9..3e3d3abb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -44,10 +44,12 @@ add_executable(hpcore src/comm/comm_session.cpp src/comm/comm_server.cpp src/comm/comm_client.cpp - src/fbschema/common_helpers.cpp - src/fbschema/p2pmsg_helpers.cpp - src/fbschema/ledger_helpers.cpp - src/jsonschema/usrmsg_helpers.cpp + src/msg/fbuf/common_helpers.cpp + src/msg/fbuf/p2pmsg_helpers.cpp + src/msg/fbuf/ledger_helpers.cpp + src/msg/json/usrmsg_json.cpp + src/msg/bson/usrmsg_bson.cpp + src/msg/usrmsg_parser.cpp src/p2p/peer_session_handler.cpp src/p2p/p2p.cpp src/usr/user_session_handler.cpp diff --git a/README.md b/README.md index fe80a571..c9dd3ce1 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,7 @@ A C++ version of hotpocket designed for production envrionments, original protot * Crypto - Libsodium https://github.com/jedisct1/libsodium * Websockets - Server: [Websocketd (forked)](https://github.com/codetsunami/websocketd) | Client: [Websocat](https://github.com/vi/websocat) | Pipe: [netcat (OpenBSD)](https://man.openbsd.org/nc.1) * RapidJSON - http://rapidjson.org +* jsoncons (for BSON) - https://github.com/danielaparker/jsoncons * P2P Protocol - https://google.github.io/flatbuffers * Fuse filesystem - https://github.com/libfuse/libfuse * Boost - https://www.boost.org @@ -44,6 +45,12 @@ Following Instructions are based on Boost [getting started](https://www.boost.or 2. Navigate to the extracted directory. 3. Run `sudo cp -r include/rapidjson /usr/local/include/` +#### Install jsoncons +1. Download and extract jsoncons v0.153.3 source from [here](https://github.com/danielaparker/jsoncons/archive/v0.153.3.zip). +2. Navigate to the extracted directory. +3. Run `sudo cp -r include/jsoncons /usr/local/include/` +4. Run `sudo mkdir -p /usr/local/include/jsoncons_ext/ && sudo cp -r include/jsoncons_ext/bson /usr/local/include/jsoncons_ext/` + #### Install FlatBuffers Instructions are based on [this](https://google.github.io/flatbuffers/). @@ -61,7 +68,7 @@ make ##### Compiling FlatBuffers message definitions Example: When you make a change to `p2pmsg_content_.fbc` defnition file, you need to run this: -`flatc -o src/fbschema/ --gen-mutable --cpp src/fbschema/p2pmsg_content.fbs` +`flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg_content.fbs` #### Install libfuse 1. `sudo apt-get install -y meson ninja-build pkg-config` diff --git a/examples/hpclient/file-client.js b/examples/hpclient/file-client.js index 64f6858e..fb7a364d 100644 --- a/examples/hpclient/file-client.js +++ b/examples/hpclient/file-client.js @@ -6,7 +6,6 @@ const readline = require('readline') // sodium has a trigger when it's ready, we will wait and execute from there sodium.ready.then(main).catch((e) => { console.log(e) }) - function main() { var keys = sodium.crypto_sign_keypair() @@ -34,15 +33,6 @@ function main() { rejectUnauthorized: false }) - /* anatomy of a public challenge - { - version: '0.1', - type: 'public_challenge', - challenge: '' - } - */ - - // if the console ctrl + c's us we should close ws gracefully process.once('SIGINT', function (code) { console.log('SIGINT received...'); @@ -83,7 +73,8 @@ function main() { type: 'handshake_response', challenge: m.challenge, sig: Buffer.from(sigbytes).toString('hex'), - pubkey: pkhex + pubkey: pkhex, + protocol: 'json' } ws.send(JSON.stringify(response)) diff --git a/examples/hpclient/package-lock.json b/examples/hpclient/package-lock.json index 558a2792..6487a803 100644 --- a/examples/hpclient/package-lock.json +++ b/examples/hpclient/package-lock.json @@ -7,19 +7,52 @@ "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz", "integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==" }, + "base64-js": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz", + "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==" + }, + "bson": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/bson/-/bson-4.0.4.tgz", + "integrity": "sha512-Ioi3TD0/1V3aI8+hPfC56TetYmzfq2H07jJa9A1lKTxWsFtHtYdLMGMXjtGEg9v0f72NSM07diRQEUNYhLupIA==", + "requires": { + "buffer": "^5.1.0", + "long": "^4.0.0" + } + }, + "buffer": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.6.0.tgz", + "integrity": "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, + "ieee754": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz", + "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==" + }, "libsodium": { - "version": "0.7.5", - "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.5.tgz", - "integrity": "sha512-0YVU2QJc5sDR5HHkGCaliYImS7pGeXi11fiOfm4DirBd96PJVZIn3LJa06ZOFjLNsWkL3UbNjYhLRUOABPL9vw==" + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.6.tgz", + "integrity": "sha512-hPb/04sEuLcTRdWDtd+xH3RXBihpmbPCsKW/Jtf4PsvdyKh+D6z2D2gvp/5BfoxseP+0FCOg66kE+0oGUE/loQ==" }, "libsodium-wrappers": { - "version": "0.7.5", - "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.5.tgz", - "integrity": "sha512-QE9Q+FxLLGdJRiJTuC2GB3LEHZeHX/VcbMQeNPdAixEKo86JPy6bOWND1XmMLu0tjWUu0xIY0YpJYQApxIZwbQ==", + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.6.tgz", + "integrity": "sha512-OUO2CWW5bHdLr6hkKLHIKI4raEkZrf3QHkhXsJ1yCh6MZ3JDA7jFD3kCATNquuGSG6MjjPHQIQms0y0gBDzjQg==", "requires": { - "libsodium": "0.7.5" + "libsodium": "0.7.6" } }, + "long": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/long/-/long-4.0.0.tgz", + "integrity": "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==" + }, "ws": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/ws/-/ws-7.1.2.tgz", diff --git a/examples/hpclient/package.json b/examples/hpclient/package.json index 83643285..d28333ae 100644 --- a/examples/hpclient/package.json +++ b/examples/hpclient/package.json @@ -1,6 +1,7 @@ { "dependencies": { - "libsodium-wrappers": "0.7.5", - "ws": "7.1.2" + "libsodium-wrappers": "0.7.6", + "ws": "7.1.2", + "bson": "4.0.4" } } diff --git a/examples/hpclient/text-client.js b/examples/hpclient/text-client.js index c6c48877..748915a5 100644 --- a/examples/hpclient/text-client.js +++ b/examples/hpclient/text-client.js @@ -1,109 +1,127 @@ -// -// HotPocket client example code adopted from: -// https://github.com/codetsunami/hotpocket/blob/master/hp_client.js -// +// Usage: +// node text-client.js [json|bson] +// node text-client.js [json|bson] [] +// node text-client.js [json|bson] [] [] const fs = require('fs') const ws_api = require('ws'); const sodium = require('libsodium-wrappers') const readline = require('readline') - -// sodium has a trigger when it's ready, we will wait and execute from there -sodium.ready.then(main).catch((e) => { console.log(e) }) - +const bson = require('bson'); +const { exit } = require('process'); function main() { - var keys = sodium.crypto_sign_keypair() + // We use json protocol for messages until handshake completion. + let is_json = true; + if (process.argv.length < 3) { + console.log("Not enough arguments. 'protocol: [json|bson] required") + return; + } + const protocol = process.argv[2]; + if (protocol != 'json' && protocol != 'bson') { + console.log("Not enough arguments. 'protocol: [json|bson] required") + return; + } - // check for client keys - if (!fs.existsSync('.hp_client_keys')) { + let server = 'wss://localhost:8080' + if (process.argv.length == 4) server = 'wss://localhost:' + process.argv[3] + if (process.argv.length == 5) server = 'wss://' + process.argv[3] + ':' + process.argv[4] + + const ws = new ws_api(server, { + rejectUnauthorized: false + }) + + let keys = {}; + const key_file = '.hp_client_keys'; + if (!fs.existsSync(key_file)) { + keys = sodium.crypto_sign_keypair(); keys.privateKey = sodium.to_hex(keys.privateKey) keys.publicKey = sodium.to_hex(keys.publicKey) - fs.writeFileSync('.hp_client_keys', JSON.stringify(keys)) + fs.writeFileSync(key_file, JSON.stringify(keys)) } else { - keys = JSON.parse(fs.readFileSync('.hp_client_keys')) + keys = JSON.parse(fs.readFileSync(key_file)) keys.privateKey = Uint8Array.from(Buffer.from(keys.privateKey, 'hex')) keys.publicKey = Uint8Array.from(Buffer.from(keys.publicKey, 'hex')) } - - var server = 'wss://localhost:8080' - - if (process.argv.length == 3) server = 'wss://localhost:' + process.argv[2] - - if (process.argv.length == 4) server = 'wss://' + process.argv[2] + ':' + process.argv[3] - - var ws = new ws_api(server, { - rejectUnauthorized: false - }) - - /* anatomy of a public challenge - { - version: '0.1', - type: 'public_challenge', - challenge: '' - } - */ - + const pkhex = 'ed' + Buffer.from(keys.publicKey).toString('hex'); + console.log('My public key is: ' + pkhex); // if the console ctrl + c's us we should close ws gracefully - process.once('SIGINT', function (code) { + process.once('SIGINT', function () { console.log('SIGINT received...'); - ws.close() + ws.close(); }); + function encode_buffer(buffer) { + return is_json ? buffer.toString('hex') : buffer; + } + + function serialize_object(obj) { + return is_json ? Buffer.from(JSON.stringify(obj)) : bson.serialize(obj); + } + + function deserialize_message(m) { + return is_json ? JSON.parse(m) : bson.deserialize(m); + } + + function create_handshake_response(challenge) { + const sig_bytes = sodium.crypto_sign_detached(challenge, keys.privateKey); + return { + type: 'handshake_response', + challenge: challenge, + sig: encode_buffer(Buffer.from(sig_bytes)), + pubkey: pkhex, + protocol: protocol + } + } + function create_input_container(inp) { - let inp_container = { + + if (inp.length == 0) + return null; + + const inp_container = { nonce: (new Date()).getTime().toString(), - input: Buffer.from(inp).toString('hex'), - max_lcl_seqno: 9999999 + input: encode_buffer(Buffer.from(inp)), + max_lcl_seqno: 999999999 } - let inp_container_bytes = JSON.stringify(inp_container); - let sig_bytes = sodium.crypto_sign_detached(inp_container_bytes, keys.privateKey); - let signed_inp_container = { + const inp_container_bytes = serialize_object(inp_container); + const sig_bytes = Buffer.from(sodium.crypto_sign_detached(inp_container_bytes, keys.privateKey)); + + const signed_inp_container = { type: "contract_input", - input_container: inp_container_bytes.toString('hex'), - sig: Buffer.from(sig_bytes).toString('hex') + input_container: encode_buffer(inp_container_bytes), + sig: encode_buffer(sig_bytes) } - return JSON.stringify(signed_inp_container); + return signed_inp_container; } function create_read_request_container(inp) { if (inp.length == 0) - return ""; + return null; - let container = { + return { type: "contract_read_request", - content: Buffer.from(inp).toString('hex'), + content: encode_buffer(Buffer.from(inp)) } - - return JSON.stringify(container); } function create_status_request() { - let statreq = { type: 'stat' } - return JSON.stringify(statreq); + return { type: 'stat' }; } - function handle_public_challange(m) { - let pkhex = 'ed' + Buffer.from(keys.publicKey).toString('hex'); - console.log('My public key is: ' + pkhex); + function handle_handshake_challange(m) { // sign the challenge and send back the response - var sigbytes = sodium.crypto_sign_detached(m.challenge, keys.privateKey); - var response = { - type: 'handshake_response', - challenge: m.challenge, - sig: Buffer.from(sigbytes).toString('hex'), - pubkey: pkhex - } - - ws.send(JSON.stringify(response)) + const response = create_handshake_response(m.challenge); + ws.send(serialize_object(response)); + is_json = (protocol == 'json'); // start listening for stdin const rl = readline.createInterface({ @@ -111,23 +129,22 @@ function main() { output: process.stdout }); - console.log("Ready to accept inputs.") + console.log("Ready to accept inputs."); // Capture user input from the console. - var input_pump = () => { + const input_pump = () => { rl.question('', (inp) => { - let msgtosend = ""; - + let msg; if (inp == "stat") - msgtosend = create_status_request(); + msg = create_status_request(); else if (inp.startsWith("read ")) - msgtosend = create_read_request_container(inp.substr(5)); + msg = create_read_request_container(inp.substr(5)); else - msgtosend = create_input_container(inp); + msg = create_input_container(inp); - if (msgtosend.length > 0) - ws.send(msgtosend) + if (msg != null) + ws.send(serialize_object(msg)) input_pump(); }) @@ -135,24 +152,25 @@ function main() { input_pump(); } - ws.on('message', (data) => { + ws.on('message', (received_msg) => { try { - m = JSON.parse(data) + m = deserialize_message(received_msg); } catch (e) { - console.log("Exception: " + data); - return + console.log("Exception deserializing: " + received_msg); + return; } if (m.type == 'handshake_challenge') { - handle_public_challange(m); + handle_handshake_challange(m); } else if (m.type == 'contract_output' || m.type == 'contract_read_response') { - console.log(Buffer.from(m.content, 'hex').toString()); + const contract_reply = is_json ? Buffer.from(m.content, 'hex').toString() : m.content.toString(); + console.log(contract_reply); } else if (m.type == 'contract_input_status') { if (m.status != "accepted") - console.log("Input status: " + m.status); + console.log("Input status: " + m.status + " | reason: " + m.reason); } else { console.log(m); @@ -162,5 +180,9 @@ function main() { ws.on('close', () => { console.log('Server disconnected.'); + exit(); }); } + +// sodium has a trigger when it's ready, we will wait and execute from there +sodium.ready.then(main).catch((e) => { console.log(e) }) \ No newline at end of file diff --git a/src/comm/comm_session.cpp b/src/comm/comm_session.cpp index 0628e9a5..a6ceb2e1 100644 --- a/src/comm/comm_session.cpp +++ b/src/comm/comm_session.cpp @@ -71,6 +71,13 @@ namespace comm } else if (read_len > 0) { + if (!is_binary) + { + read_buffer.resize(read_len); + if (read(read_fd, read_buffer.data(), read_len) < read_len) + return -1; + } + int res = on_message(std::string_view(read_buffer.data(), read_len)); read_buffer.clear(); // Clear the buffer after read operation. read_buffer_filled_size = 0; @@ -91,6 +98,12 @@ namespace comm return peer_sess_handler.on_message(*this, message); } + int comm_session::send(const std::vector &message) const + { + std::string_view sv(reinterpret_cast(message.data()), message.size()); + send(sv); + } + int comm_session::send(std::string_view message) const { if (state == SESSION_STATE::CLOSED) diff --git a/src/comm/comm_session.hpp b/src/comm/comm_session.hpp index b1382358..e8e17621 100644 --- a/src/comm/comm_session.hpp +++ b/src/comm/comm_session.hpp @@ -58,6 +58,7 @@ public: const bool is_binary, const bool is_inbound, const uint64_t (&metric_thresholds)[4]); int on_connect(); int attempt_read(const uint64_t max_msg_size); + int send(const std::vector &message) const; int send(std::string_view message) const; void close(const bool invoke_handler = true); diff --git a/src/cons/cons.cpp b/src/cons/cons.cpp index 2d32f81e..8b2ad5a9 100644 --- a/src/cons/cons.cpp +++ b/src/cons/cons.cpp @@ -3,9 +3,10 @@ #include "../usr/usr.hpp" #include "../usr/user_input.hpp" #include "../p2p/p2p.hpp" -#include "../fbschema/p2pmsg_helpers.hpp" -#include "../fbschema/common_helpers.hpp" -#include "../jsonschema/usrmsg_helpers.hpp" +#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/common_helpers.hpp" +#include "../msg/usrmsg_parser.hpp" +#include "../msg/usrmsg_common.hpp" #include "../p2p/peer_session_handler.hpp" #include "../hplog.hpp" #include "../crypto.hpp" @@ -16,8 +17,7 @@ #include "ledger_handler.hpp" #include "cons.hpp" -namespace p2pmsg = fbschema::p2pmsg; -namespace jusrmsg = jsonschema::usrmsg; +namespace p2pmsg = msg::fbuf::p2pmsg; namespace cons { @@ -126,9 +126,9 @@ namespace cons std::lock_guard lock(p2p::ctx.collected_msgs.npl_messages_mutex); for (const auto &npl : p2p::ctx.collected_msgs.npl_messages) { - const fbschema::p2pmsg::Container *container = fbschema::p2pmsg::GetContainer(npl.data()); + const msg::fbuf::p2pmsg::Container *container = msg::fbuf::p2pmsg::GetContainer(npl.data()); // Only the npl messages with a valid lcl will be passed down to the contract. lcl should match the previous round's lcl - if (fbschema::flatbuff_bytes_to_sv(container->lcl()) != ctx.lcl) + if (msg::fbuf::flatbuff_bytes_to_sv(container->lcl()) != ctx.lcl) continue; ctx.candidate_npl_messages.push_back(std::move(npl)); @@ -325,12 +325,12 @@ namespace cons for (auto &[sid, user] : usr::ctx.users) { - std::list usermsgs; - usermsgs.splice(usermsgs.end(), user.submitted_inputs); + std::list user_inputs; + user_inputs.splice(user_inputs.end(), user.submitted_inputs); // We should create an entry for each user pubkey, even if the user has no inputs. This is // because this data map will be used to track connected users as well in addition to inputs. - nup.user_messages.try_emplace(user.pubkey, std::move(usermsgs)); + nup.user_inputs.try_emplace(user.pubkey, std::move(user_inputs)); } flatbuffers::FlatBufferBuilder fbuf(1024); @@ -338,7 +338,7 @@ namespace cons p2p::broadcast_message(fbuf, true); LOG_DBG << "NUP sent." - << " users:" << nup.user_messages.size(); + << " users:" << nup.user_inputs.size(); } /** @@ -354,7 +354,7 @@ namespace cons std::lock_guard nups_lock(p2p::ctx.collected_msgs.nonunl_proposals_mutex); for (const p2p::nonunl_proposal &p : p2p::ctx.collected_msgs.nonunl_proposals) { - for (const auto &[pubkey, umsgs] : p.user_messages) + for (const auto &[pubkey, umsgs] : p.user_inputs) { // Locate this user's socket session in case we need to send any status messages regarding user inputs. const comm::comm_session *session = usr::get_session_by_pubkey(pubkey); @@ -367,21 +367,23 @@ namespace cons size_t total_input_len = 0; bool appbill_balance_exceeded = false; - for (const usr::user_submitted_message &umsg : umsgs) + for (const usr::user_input &umsg : umsgs) { + msg::usrmsg::usrmsg_parser parser(umsg.protocol); + const char *reject_reason = NULL; const std::string sig_hash = crypto::get_hash(umsg.sig); // Check for duplicate messages using hash of the signature. if (ctx.recent_userinput_hashes.try_emplace(sig_hash)) { - // Verify the signature of the message content. - if (crypto::verify(umsg.content, umsg.sig, pubkey) == 0) + // Verify the signature of the input_container. + if (crypto::verify(umsg.input_container, umsg.sig, pubkey) == 0) { std::string nonce; std::string input; uint64_t max_lcl_seqno; - jusrmsg::extract_input_container(input, nonce, max_lcl_seqno, umsg.content); + parser.extract_input_container(input, nonce, max_lcl_seqno, umsg.input_container); // Ignore the input if our ledger has passed the input TTL. if (max_lcl_seqno > ctx.led_seq_no) @@ -406,37 +408,38 @@ namespace cons // Abandon processing further inputs from this user when we find out // an input cannot be processed with the account balance. appbill_balance_exceeded = true; - reject_reason = jusrmsg::REASON_APPBILL_BALANCE_EXCEEDED; + reject_reason = msg::usrmsg::REASON_APPBILL_BALANCE_EXCEEDED; } } else { - reject_reason = jusrmsg::REASON_APPBILL_BALANCE_EXCEEDED; + reject_reason = msg::usrmsg::REASON_APPBILL_BALANCE_EXCEEDED; } } else { LOG_DBG << "User message bad max ledger seq expired."; - reject_reason = jusrmsg::REASON_MAX_LEDGER_EXPIRED; + reject_reason = msg::usrmsg::REASON_MAX_LEDGER_EXPIRED; } } else { LOG_DBG << "User message bad signature."; - reject_reason = jusrmsg::REASON_BAD_SIG; + reject_reason = msg::usrmsg::REASON_BAD_SIG; } } else { LOG_DBG << "Duplicate user message."; - reject_reason = jusrmsg::REASON_DUPLICATE_MSG; + reject_reason = msg::usrmsg::REASON_DUPLICATE_MSG; } // Send the request status result if this user is connected to us. if (session != NULL) { - usr::send_input_status(*session, - reject_reason == NULL ? jusrmsg::STATUS_ACCEPTED : jusrmsg::STATUS_REJECTED, + usr::send_input_status(parser, + *session, + reject_reason == NULL ? msg::usrmsg::STATUS_ACCEPTED : msg::usrmsg::STATUS_REJECTED, reject_reason == NULL ? "" : reject_reason, umsg.sig); } @@ -816,10 +819,12 @@ namespace cons std::string outputtosend; outputtosend.swap(cand_output.output); - std::string msg; - jusrmsg::create_contract_output_container(msg, outputtosend); - const usr::connected_user &user = user_itr->second; + msg::usrmsg::usrmsg_parser parser(user.protocol); + + std::vector msg; + parser.create_contract_output_container(msg, outputtosend); + user.session.send(msg); } } diff --git a/src/cons/ledger_handler.cpp b/src/cons/ledger_handler.cpp index 0f1edab0..99a9ba4a 100644 --- a/src/cons/ledger_handler.cpp +++ b/src/cons/ledger_handler.cpp @@ -2,9 +2,9 @@ #include "../conf.hpp" #include "../crypto.hpp" #include "../p2p/p2p.hpp" -#include "../fbschema/common_helpers.hpp" -#include "../fbschema/ledger_helpers.hpp" -#include "../fbschema/p2pmsg_helpers.hpp" +#include "../msg/fbuf/common_helpers.hpp" +#include "../msg/fbuf/ledger_helpers.hpp" +#include "../msg/fbuf/p2pmsg_helpers.hpp" #include "../hplog.hpp" #include "ledger_handler.hpp" #include "cons.hpp" @@ -12,7 +12,7 @@ namespace cons { -namespace p2pmsg = fbschema::p2pmsg; +namespace p2pmsg = msg::fbuf::p2pmsg; /** * Create and save ledger from the given proposal message. @@ -37,7 +37,7 @@ const std::tuple save_ledger(const p2p::proposal &p //Serialize lcl using flatbuffer ledger schema. flatbuffers::FlatBufferBuilder builder(1024); - const std::string_view ledger_str = fbschema::ledger::create_ledger_from_proposal(builder, proposal, led_seq_no); + const std::string_view ledger_str = msg::fbuf::ledger::create_ledger_from_proposal(builder, proposal, led_seq_no); //Get binary hash of the the serialized lcl. const std::string lcl = crypto::get_hash(ledger_str); @@ -185,10 +185,10 @@ const ledger_history load_ledger() if (file.read(buffer.data(), size)) { const uint8_t *ledger_buf_ptr = reinterpret_cast(buffer.data()); - const fbschema::ledger::Ledger *ledger = fbschema::ledger::GetLedger(ledger_buf_ptr); + const msg::fbuf::ledger::Ledger *ledger = msg::fbuf::ledger::GetLedger(ledger_buf_ptr); ledger_cache_entry c; c.lcl = file_name; - c.state = fbschema::flatbuff_bytes_to_sv(ledger->state()); + c.state = msg::fbuf::flatbuff_bytes_to_sv(ledger->state()); ldg_hist.cache.emplace(seq_no, std::move(c)); //lcl_cache -> [seq_no-hash] } diff --git a/src/jsonschema/usrmsg_helpers.hpp b/src/jsonschema/usrmsg_helpers.hpp deleted file mode 100644 index 4eda1b63..00000000 --- a/src/jsonschema/usrmsg_helpers.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef _HP_JSONSCHEMA_USRMSG_HELPERS_ -#define _HP_JSONSCHEMA_USRMSG_HELPERS_ - -#include "../pchheader.hpp" - -namespace jsonschema::usrmsg -{ - -// Message field names exposed out of this namespace. -extern const char* const FLD_TYPE; - -// Message types -constexpr const char* MSGTYPE_HANDSHAKE_CHALLENGE = "handshake_challenge"; -constexpr const char* MSGTYPE_HANDSHAKE_RESPONSE = "handshake_response"; -constexpr const char* MSGTYPE_CONTRACT_READ_REQUEST = "contract_read_request"; -constexpr const char* MSGTYPE_CONTRACT_READ_RESPONSE = "contract_read_response"; -constexpr const char* MSGTYPE_CONTRACT_INPUT = "contract_input"; -constexpr const char* MSGTYPE_CONTRACT_INPUT_STATUS = "contract_input_status"; -constexpr const char* MSGTYPE_CONTRACT_OUTPUT = "contract_output"; -constexpr const char* MSGTYPE_STAT = "stat"; -constexpr const char* MSGTYPE_STAT_RESPONSE = "stat_response"; -constexpr const char* MSGTYPE_UNKNOWN = "unknown"; - -constexpr const char *STATUS_ACCEPTED = "accepted"; -constexpr const char *STATUS_REJECTED = "rejected"; -constexpr const char *REASON_BAD_MSG_FORMAT = "bad_msg_format"; -constexpr const char *REASON_INVALID_MSG_TYPE = "invalid_msg_type"; -constexpr const char *REASON_DUPLICATE_MSG = "dup_msg"; -constexpr const char *REASON_BAD_SIG = "bad_sig"; -constexpr const char *REASON_APPBILL_BALANCE_EXCEEDED = "appbill_balance_exceeded"; -constexpr const char *REASON_MAX_LEDGER_EXPIRED = "max_ledger_expired"; - -void create_user_challenge(std::string &msg, std::string &challengehex); - -void create_status_response(std::string &msg); - -void create_contract_input_status(std::string &msg, std::string_view status, std::string_view reason, std::string_view input_sig); - -void create_contract_read_response_container(std::string &msg, std::string_view content); - -void create_contract_output_container(std::string &msg, std::string_view content); - -int verify_user_challenge_response(std::string &extracted_pubkeyhex, std::string_view response, std::string_view original_challenge); - -int extract_read_request(std::string &extracted_content, const rapidjson::Document &d); - -int extract_signed_input_container(std::string &extracted_input_container, std::string &extracted_sig, const rapidjson::Document &d); - -int extract_input_container(std::string &input, std::string &nonce, uint64_t &max_lcl_seqno, std::string_view contentjson); - -int parse_user_message(rapidjson::Document &d, std::string_view message); - -} // namespace jsonschema::usrmsg - -#endif \ No newline at end of file diff --git a/src/msg/bson/usrmsg_bson.cpp b/src/msg/bson/usrmsg_bson.cpp new file mode 100644 index 00000000..678bec55 --- /dev/null +++ b/src/msg/bson/usrmsg_bson.cpp @@ -0,0 +1,252 @@ +#include "../../pchheader.hpp" +#include "../../util.hpp" +#include "../../cons/cons.hpp" +#include "../../hplog.hpp" +#include "../usrmsg_common.hpp" +#include "usrmsg_bson.hpp" + +namespace msg::usrmsg::bson +{ + /** + * Constructs a status response message. + * @param msg String reference to copy the generated bson message into. + * Message format: + * { + * "type": "stat_response", + * "lcl": "", + * "lcl_seqno": + * } + */ + void create_status_response(std::vector &msg) + { + jsoncons::bson::bson_bytes_encoder encoder(msg); + encoder.begin_object(); + encoder.key(msg::usrmsg::FLD_TYPE); + encoder.string_value(msg::usrmsg::MSGTYPE_STAT_RESPONSE); + encoder.key(msg::usrmsg::FLD_LCL); + encoder.string_value(cons::ctx.lcl); + encoder.key(msg::usrmsg::FLD_LCL_SEQ); + encoder.int64_value(cons::ctx.led_seq_no); + encoder.end_object(); + encoder.flush(); + } + + /** + * Constructs a contract input status message. + * @param msg String reference to copy the generated bson message into. + * Message format: + * { + * "type": "contract_input_status", + * "status": "", + * "reason": "", + * "input_sig": + * } + * @param is_accepted Whether the original message was accepted or not. + * @param reason Rejected reason. Empty if accepted. + * @param input_sig Binary signature of the original input message which generated this result. + */ + void create_contract_input_status(std::vector &msg, std::string_view status, std::string_view reason, std::string_view input_sig) + { + jsoncons::bson::bson_bytes_encoder encoder(msg); + encoder.begin_object(); + encoder.key(msg::usrmsg::FLD_TYPE); + encoder.string_value(msg::usrmsg::MSGTYPE_CONTRACT_INPUT_STATUS); + encoder.key(msg::usrmsg::FLD_STATUS); + encoder.string_value(status); + encoder.key(msg::usrmsg::FLD_REASON); + encoder.string_value(reason); + encoder.key(msg::usrmsg::FLD_INPUT_SIG); + encoder.byte_string_value(input_sig); + encoder.end_object(); + encoder.flush(); + } + + /** + * Constructs a contract read response message. + * @param msg String reference to copy the generated bson message into. + * Message format: + * { + * "type": "contract_read_response", + * "content": + * } + * @param content The contract binary output content to be put in the message. + */ + void create_contract_read_response_container(std::vector &msg, std::string_view content) + { + jsoncons::bson::bson_bytes_encoder encoder(msg); + encoder.begin_object(); + encoder.key(msg::usrmsg::FLD_TYPE); + encoder.string_value(msg::usrmsg::MSGTYPE_CONTRACT_READ_RESPONSE); + encoder.key(msg::usrmsg::FLD_CONTENT); + encoder.byte_string_value(content); + encoder.end_object(); + encoder.flush(); + } + + /** + * Constructs a contract output container message. + * @param msg String reference to copy the generated bson message into. + * Message format: + * { + * "type": "contract_output", + * "lcl": "" + * "lcl_seqno": , + * "content": + * } + * @param content The contract binary output content to be put in the message. + */ + void create_contract_output_container(std::vector &msg, std::string_view content) + { + jsoncons::bson::bson_bytes_encoder encoder(msg); + encoder.begin_object(); + encoder.key(msg::usrmsg::FLD_TYPE); + encoder.string_value(msg::usrmsg::MSGTYPE_CONTRACT_OUTPUT); + encoder.key(msg::usrmsg::FLD_LCL); + encoder.string_value(cons::ctx.lcl); + encoder.key(msg::usrmsg::FLD_LCL_SEQ); + encoder.int64_value(cons::ctx.led_seq_no); + encoder.key(msg::usrmsg::FLD_CONTENT); + encoder.byte_string_value(content); + encoder.end_object(); + encoder.flush(); + } + + /** + * Parses a bson message sent by a user. + * @param d BSON document to which the parsed bson should be loaded. + * @param message The message to parse. + * Accepted message format: + * { + * 'type': '' + * ... + * } + * @return 0 on successful parsing. -1 for failure. + */ + int parse_user_message(jsoncons::ojson &d, std::string_view message) + { + try + { + d = jsoncons::bson::decode_bson(message); + } + catch (const std::exception &e) + { + LOG_DBG << "User bson message parsing failed."; + return -1; + } + + if (!d[FLD_TYPE].is_string()) + { + LOG_DBG << "User bson message 'type' missing or invalid."; + return -1; + } + + return 0; + } + + /** + * Extracts the message 'type' value from the bson document. + */ + int extract_type(std::string &extracted_type, const jsoncons::ojson &d) + { + extracted_type = d[FLD_TYPE].as(); + return 0; + } + + /** + * Extracts a contract read request message sent by user. + * + * @param extracted_content The content to be passed to the contract, extracted from the message. +* @param d The bson document holding the read request message. + * Accepted signed input container format: + * { + * "type": "contract_read_request", + * "content": + * } + * @return 0 on successful extraction. -1 for failure. + */ + int extract_read_request(std::string &extracted_content, const jsoncons::ojson &d) + { + if (!d[msg::usrmsg::FLD_CONTENT].is_byte_string_view()) + { + LOG_DBG << "Read request 'content' fields missing or invalid."; + return -1; + } + + const jsoncons::byte_string_view &bsv = d[msg::usrmsg::FLD_CONTENT].as_byte_string_view(); + extracted_content = std::string_view(reinterpret_cast(bsv.data()), bsv.size()); + return 0; + } + + /** + * Extracts a signed input container message sent by user. + * + * @param extracted_input_container The input container extracted from the message. + * @param extracted_sig The binary signature extracted from the message. + * @param d The bson document holding the input container. + * Accepted signed input container format: + * { + * "type": "contract_input", + * "input_container": , + * "sig": + * } + * @return 0 on successful extraction. -1 for failure. + */ + int extract_signed_input_container( + std::string &extracted_input_container, std::string &extracted_sig, const jsoncons::ojson &d) + { + if (!d[msg::usrmsg::FLD_INPUT_CONTAINER].is_byte_string_view() || !d[msg::usrmsg::FLD_SIG].is_byte_string_view()) + { + LOG_DBG << "User signed input required fields missing or invalid."; + return -1; + } + + const jsoncons::byte_string_view &bsv1 = d[msg::usrmsg::FLD_INPUT_CONTAINER].as_byte_string_view(); + extracted_input_container = std::string_view(reinterpret_cast(bsv1.data()), bsv1.size()); + + const jsoncons::byte_string_view &bsv2 = d[msg::usrmsg::FLD_SIG].as_byte_string_view(); + extracted_sig = std::string_view(reinterpret_cast(bsv2.data()), bsv2.size()); + + return 0; + } + + /** + * Extract the individual components of a given input container bson. + * @param input The extracted input. + * @param nonce The extracted nonce. + * @param max_lcl_seqno The extracted max ledger sequence no. + * @param contentjson The bson input container message. + * { + * "input": , + * "nonce": "", + * "max_lcl_seqno": + * } + * @return 0 on succesful extraction. -1 on failure. + */ + int extract_input_container(std::string &input, std::string &nonce, uint64_t &max_lcl_seqno, std::string_view contentbson) + { + jsoncons::ojson d; + try + { + d = jsoncons::bson::decode_bson(contentbson); + } + catch (const std::exception &e) + { + LOG_DBG << "User input container bson parsing failed."; + return -1; + } + + if (!d[msg::usrmsg::FLD_INPUT].is_byte_string_view() || !d[msg::usrmsg::FLD_NONCE].is_string() || !d[msg::usrmsg::FLD_MAX_LCL_SEQ].is_uint64()) + { + LOG_DBG << "User input container required fields missing or invalid."; + return -1; + } + + const jsoncons::byte_string_view &bsv = d[msg::usrmsg::FLD_INPUT].as_byte_string_view(); + input = std::string_view(reinterpret_cast(bsv.data()), bsv.size()); + + nonce = d[msg::usrmsg::FLD_NONCE].as(); + max_lcl_seqno = d[msg::usrmsg::FLD_MAX_LCL_SEQ].as(); + return 0; + } + +} // namespace msg::usrmsg::bson \ No newline at end of file diff --git a/src/msg/bson/usrmsg_bson.hpp b/src/msg/bson/usrmsg_bson.hpp new file mode 100644 index 00000000..db803650 --- /dev/null +++ b/src/msg/bson/usrmsg_bson.hpp @@ -0,0 +1,37 @@ +#ifndef _HP_MSG_BSON_USRMSG_BSON_ +#define _HP_MSG_BSON_USRMSG_BSON_ + +#include "../../pchheader.hpp" + +namespace msg::usrmsg::bson +{ + + void create_user_challenge(std::vector &msg, std::string &challengehex); + + void create_status_response(std::vector &msg); + + void create_contract_input_status(std::vector &msg, std::string_view status, std::string_view reason, + std::string_view input_sig); + + void create_contract_read_response_container(std::vector &msg, std::string_view content); + + void create_contract_output_container(std::vector &msg, std::string_view content); + + int verify_user_handshake_response(std::string &extracted_pubkeyhex, std::string &extracted_protocol, + std::string_view response, std::string_view original_challenge); + + int parse_user_message(jsoncons::ojson &d, std::string_view message); + + int extract_type(std::string &extracted_type, const jsoncons::ojson &d); + + int extract_read_request(std::string &extracted_content, const jsoncons::ojson &d); + + int extract_signed_input_container(std::string &extracted_input_container, std::string &extracted_sig, + const jsoncons::ojson &d); + + int extract_input_container(std::string &input, std::string &nonce, + uint64_t &max_lcl_seqno, std::string_view contentbson); + +} // namespace msg::usrmsg::bson + +#endif \ No newline at end of file diff --git a/src/fbschema/common_helpers.cpp b/src/msg/fbuf/common_helpers.cpp similarity index 98% rename from src/fbschema/common_helpers.cpp rename to src/msg/fbuf/common_helpers.cpp index 0008f5bf..ffddefb3 100644 --- a/src/fbschema/common_helpers.cpp +++ b/src/msg/fbuf/common_helpers.cpp @@ -1,6 +1,6 @@ #include "common_helpers.hpp" -namespace fbschema +namespace msg::fbuf { //---Conversion helpers from flatbuffers data types to std data types---// @@ -123,4 +123,4 @@ namespace fbschema return builder.CreateVector(fbvec); } -} // namespace fbschema \ No newline at end of file +} // namespace msg::fbuf \ No newline at end of file diff --git a/src/fbschema/common_helpers.hpp b/src/msg/fbuf/common_helpers.hpp similarity index 90% rename from src/fbschema/common_helpers.hpp rename to src/msg/fbuf/common_helpers.hpp index 1505f6c3..7f2abfbe 100644 --- a/src/fbschema/common_helpers.hpp +++ b/src/msg/fbuf/common_helpers.hpp @@ -1,11 +1,11 @@ -#ifndef _HP_FBSCHEMA_COMMON_HELPERS_ -#define _HP_FBSCHEMA_COMMON_HELPERS_ +#ifndef _HP_MSG_FBUF_COMMON_HELPERS_ +#define _HP_MSG_FBUF_COMMON_HELPERS_ -#include "../pchheader.hpp" -#include "../hpfs/h32.hpp" +#include "../../pchheader.hpp" +#include "../../hpfs/h32.hpp" #include "common_schema_generated.h" -namespace fbschema +namespace msg::fbuf { /** * This section contains common Flatbuffer message reading/writing helpers. @@ -44,6 +44,6 @@ stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, c const flatbuffers::Offset>> stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map &map); -} // namespace fbschema +} // namespace msg::fbuf #endif \ No newline at end of file diff --git a/src/fbschema/common_schema.fbs b/src/msg/fbuf/common_schema.fbs similarity index 90% rename from src/fbschema/common_schema.fbs rename to src/msg/fbuf/common_schema.fbs index 85fb7a4c..1628e6bd 100644 --- a/src/fbschema/common_schema.fbs +++ b/src/msg/fbuf/common_schema.fbs @@ -1,5 +1,5 @@ //IDL file for common types. -namespace fbschema; +namespace msg.fbuf; table BytesKeyValuePair { //A key, value pair of byte[]. key:[ubyte]; diff --git a/src/fbschema/common_schema_generated.h b/src/msg/fbuf/common_schema_generated.h similarity index 89% rename from src/fbschema/common_schema_generated.h rename to src/msg/fbuf/common_schema_generated.h index f1e4c578..f3351c6f 100644 --- a/src/fbschema/common_schema_generated.h +++ b/src/msg/fbuf/common_schema_generated.h @@ -1,18 +1,22 @@ // automatically generated by the FlatBuffers compiler, do not modify -#ifndef FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_ -#define FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_ +#ifndef FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ +#define FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ #include "flatbuffers/flatbuffers.h" -namespace fbschema { +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 @@ -40,6 +44,7 @@ struct BytesKeyValuePair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct BytesKeyValuePairBuilder { + typedef BytesKeyValuePair Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_key(flatbuffers::Offset> key) { @@ -52,7 +57,6 @@ struct BytesKeyValuePairBuilder { : fbb_(_fbb) { start_ = fbb_.StartTable(); } - BytesKeyValuePairBuilder &operator=(const BytesKeyValuePairBuilder &); flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); @@ -76,13 +80,14 @@ inline flatbuffers::Offset CreateBytesKeyValuePairDirect( const std::vector *value = nullptr) { auto key__ = key ? _fbb.CreateVector(*key) : 0; auto value__ = value ? _fbb.CreateVector(*value) : 0; - return fbschema::CreateBytesKeyValuePair( + 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 }; @@ -101,6 +106,7 @@ struct ByteArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct ByteArrayBuilder { + typedef ByteArray Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_array(flatbuffers::Offset> array) { @@ -110,7 +116,6 @@ struct ByteArrayBuilder { : fbb_(_fbb) { start_ = fbb_.StartTable(); } - ByteArrayBuilder &operator=(const ByteArrayBuilder &); flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); @@ -130,11 +135,12 @@ inline flatbuffers::Offset CreateByteArrayDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector *array = nullptr) { auto array__ = array ? _fbb.CreateVector(*array) : 0; - return fbschema::CreateByteArray( + return msg::fbuf::CreateByteArray( _fbb, array__); } -} // namespace fbschema +} // namespace fbuf +} // namespace msg -#endif // FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_ +#endif // FLATBUFFERS_GENERATED_COMMONSCHEMA_MSG_FBUF_H_ diff --git a/src/fbschema/ledger_helpers.cpp b/src/msg/fbuf/ledger_helpers.cpp similarity index 89% rename from src/fbschema/ledger_helpers.cpp rename to src/msg/fbuf/ledger_helpers.cpp index 08206df1..89926b7a 100644 --- a/src/fbschema/ledger_helpers.cpp +++ b/src/msg/fbuf/ledger_helpers.cpp @@ -1,10 +1,10 @@ -#include "../pchheader.hpp" +#include "../../pchheader.hpp" +#include "../../p2p/p2p.hpp" #include "ledger_schema_generated.h" -#include "../p2p/p2p.hpp" #include "common_helpers.hpp" #include "ledger_helpers.hpp" -namespace fbschema::ledger +namespace msg::fbuf::ledger { /** @@ -28,4 +28,4 @@ const std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilde return flatbuff_bytes_to_sv(builder.GetBufferPointer(), builder.GetSize()); } -} // namespace fbschema::ledger +} // namespace msg::fbuf::ledger diff --git a/src/fbschema/ledger_helpers.hpp b/src/msg/fbuf/ledger_helpers.hpp similarity index 52% rename from src/fbschema/ledger_helpers.hpp rename to src/msg/fbuf/ledger_helpers.hpp index 87793c5b..6a8bad8a 100644 --- a/src/fbschema/ledger_helpers.hpp +++ b/src/msg/fbuf/ledger_helpers.hpp @@ -1,11 +1,11 @@ -#ifndef _HP_FBSCHEMA_LEDGER_HELPERS_ -#define _HP_FBSCHEMA_LEDGER_HELPERS_ +#ifndef _HP_MSG_FBUF_LEDGER_HELPERS_ +#define _HP_MSG_FBUF_LEDGER_HELPERS_ -#include "../pchheader.hpp" +#include "../../pchheader.hpp" +#include "../../p2p/p2p.hpp" #include "ledger_schema_generated.h" -#include "../p2p/p2p.hpp" -namespace fbschema::ledger +namespace msg::fbuf::ledger { const std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no); diff --git a/src/fbschema/ledger_schema.fbs b/src/msg/fbuf/ledger_schema.fbs similarity index 85% rename from src/fbschema/ledger_schema.fbs rename to src/msg/fbuf/ledger_schema.fbs index 63f8144a..9f84e25d 100644 --- a/src/fbschema/ledger_schema.fbs +++ b/src/msg/fbuf/ledger_schema.fbs @@ -1,6 +1,6 @@ include "common_schema.fbs"; -namespace fbschema.ledger; +namespace msg.fbuf.ledger; table Ledger { seq_no:uint64; diff --git a/src/fbschema/ledger_schema_generated.h b/src/msg/fbuf/ledger_schema_generated.h similarity index 70% rename from src/fbschema/ledger_schema_generated.h rename to src/msg/fbuf/ledger_schema_generated.h index 0d19cabd..96c3bfc2 100644 --- a/src/fbschema/ledger_schema_generated.h +++ b/src/msg/fbuf/ledger_schema_generated.h @@ -1,21 +1,25 @@ // automatically generated by the FlatBuffers compiler, do not modify -#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_ -#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_ +#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_ +#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_ #include "flatbuffers/flatbuffers.h" #include "common_schema_generated.h" -namespace fbschema { +namespace msg { +namespace fbuf { namespace ledger { struct Ledger; +struct LedgerBuilder; struct RawInputList; +struct RawInputListBuilder; struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LedgerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SEQ_NO = 4, VT_TIME = 6, @@ -49,23 +53,23 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { flatbuffers::Vector *mutable_state() { return GetPointer *>(VT_STATE); } - const flatbuffers::Vector> *users() const { - return GetPointer> *>(VT_USERS); + const flatbuffers::Vector> *users() const { + return GetPointer> *>(VT_USERS); } - flatbuffers::Vector> *mutable_users() { - return GetPointer> *>(VT_USERS); + flatbuffers::Vector> *mutable_users() { + return GetPointer> *>(VT_USERS); } - const flatbuffers::Vector> *inputs() const { - return GetPointer> *>(VT_INPUTS); + const flatbuffers::Vector> *inputs() const { + return GetPointer> *>(VT_INPUTS); } - flatbuffers::Vector> *mutable_inputs() { - return GetPointer> *>(VT_INPUTS); + flatbuffers::Vector> *mutable_inputs() { + return GetPointer> *>(VT_INPUTS); } - const flatbuffers::Vector> *outputs() const { - return GetPointer> *>(VT_OUTPUTS); + const flatbuffers::Vector> *outputs() const { + return GetPointer> *>(VT_OUTPUTS); } - flatbuffers::Vector> *mutable_outputs() { - return GetPointer> *>(VT_OUTPUTS); + flatbuffers::Vector> *mutable_outputs() { + return GetPointer> *>(VT_OUTPUTS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -89,6 +93,7 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct LedgerBuilder { + typedef Ledger Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_seq_no(uint64_t seq_no) { @@ -103,20 +108,19 @@ struct LedgerBuilder { void add_state(flatbuffers::Offset> state) { fbb_.AddOffset(Ledger::VT_STATE, state); } - void add_users(flatbuffers::Offset>> users) { + void add_users(flatbuffers::Offset>> users) { fbb_.AddOffset(Ledger::VT_USERS, users); } - void add_inputs(flatbuffers::Offset>> inputs) { + void add_inputs(flatbuffers::Offset>> inputs) { fbb_.AddOffset(Ledger::VT_INPUTS, inputs); } - void add_outputs(flatbuffers::Offset>> outputs) { + void add_outputs(flatbuffers::Offset>> outputs) { fbb_.AddOffset(Ledger::VT_OUTPUTS, outputs); } explicit LedgerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - LedgerBuilder &operator=(const LedgerBuilder &); flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); @@ -130,9 +134,9 @@ inline flatbuffers::Offset CreateLedger( uint64_t time = 0, flatbuffers::Offset> lcl = 0, flatbuffers::Offset> state = 0, - flatbuffers::Offset>> users = 0, - flatbuffers::Offset>> inputs = 0, - flatbuffers::Offset>> outputs = 0) { + flatbuffers::Offset>> users = 0, + flatbuffers::Offset>> inputs = 0, + flatbuffers::Offset>> outputs = 0) { LedgerBuilder builder_(_fbb); builder_.add_time(time); builder_.add_seq_no(seq_no); @@ -150,15 +154,15 @@ inline flatbuffers::Offset CreateLedgerDirect( uint64_t time = 0, const std::vector *lcl = nullptr, const std::vector *state = nullptr, - const std::vector> *users = nullptr, - const std::vector> *inputs = nullptr, - const std::vector> *outputs = nullptr) { + const std::vector> *users = nullptr, + const std::vector> *inputs = nullptr, + const std::vector> *outputs = nullptr) { auto lcl__ = lcl ? _fbb.CreateVector(*lcl) : 0; auto state__ = state ? _fbb.CreateVector(*state) : 0; - auto users__ = users ? _fbb.CreateVector>(*users) : 0; - auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; - auto outputs__ = outputs ? _fbb.CreateVector>(*outputs) : 0; - return fbschema::ledger::CreateLedger( + auto users__ = users ? _fbb.CreateVector>(*users) : 0; + auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector>(*outputs) : 0; + return msg::fbuf::ledger::CreateLedger( _fbb, seq_no, time, @@ -170,6 +174,7 @@ inline flatbuffers::Offset CreateLedgerDirect( } struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RawInputListBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_HASH = 4, VT_INPUTS = 6 @@ -180,11 +185,11 @@ struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { flatbuffers::Vector *mutable_hash() { return GetPointer *>(VT_HASH); } - const flatbuffers::Vector> *inputs() const { - return GetPointer> *>(VT_INPUTS); + const flatbuffers::Vector> *inputs() const { + return GetPointer> *>(VT_INPUTS); } - flatbuffers::Vector> *mutable_inputs() { - return GetPointer> *>(VT_INPUTS); + flatbuffers::Vector> *mutable_inputs() { + return GetPointer> *>(VT_INPUTS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -198,19 +203,19 @@ struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct RawInputListBuilder { + typedef RawInputList Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_hash(flatbuffers::Offset> hash) { fbb_.AddOffset(RawInputList::VT_HASH, hash); } - void add_inputs(flatbuffers::Offset>> inputs) { + void add_inputs(flatbuffers::Offset>> inputs) { fbb_.AddOffset(RawInputList::VT_INPUTS, inputs); } explicit RawInputListBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - RawInputListBuilder &operator=(const RawInputListBuilder &); flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); @@ -221,7 +226,7 @@ struct RawInputListBuilder { inline flatbuffers::Offset CreateRawInputList( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset> hash = 0, - flatbuffers::Offset>> inputs = 0) { + flatbuffers::Offset>> inputs = 0) { RawInputListBuilder builder_(_fbb); builder_.add_inputs(inputs); builder_.add_hash(hash); @@ -231,21 +236,21 @@ inline flatbuffers::Offset CreateRawInputList( inline flatbuffers::Offset CreateRawInputListDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector *hash = nullptr, - const std::vector> *inputs = nullptr) { + const std::vector> *inputs = nullptr) { auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; - auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; - return fbschema::ledger::CreateRawInputList( + auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; + return msg::fbuf::ledger::CreateRawInputList( _fbb, hash__, inputs__); } -inline const fbschema::ledger::Ledger *GetLedger(const void *buf) { - return flatbuffers::GetRoot(buf); +inline const msg::fbuf::ledger::Ledger *GetLedger(const void *buf) { + return flatbuffers::GetRoot(buf); } -inline const fbschema::ledger::Ledger *GetSizePrefixedLedger(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); +inline const msg::fbuf::ledger::Ledger *GetSizePrefixedLedger(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); } inline Ledger *GetMutableLedger(void *buf) { @@ -254,27 +259,28 @@ inline Ledger *GetMutableLedger(void *buf) { inline bool VerifyLedgerBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); + return verifier.VerifyBuffer(nullptr); } inline bool VerifySizePrefixedLedgerBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); + return verifier.VerifySizePrefixedBuffer(nullptr); } inline void FinishLedgerBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.Finish(root); } inline void FinishSizePrefixedLedgerBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.FinishSizePrefixed(root); } } // namespace ledger -} // namespace fbschema +} // namespace fbuf +} // namespace msg -#endif // FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_ +#endif // FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_ diff --git a/src/fbschema/p2pmsg_container.fbs b/src/msg/fbuf/p2pmsg_container.fbs similarity index 92% rename from src/fbschema/p2pmsg_container.fbs rename to src/msg/fbuf/p2pmsg_container.fbs index bc0e8c0f..bacc2087 100644 --- a/src/fbschema/p2pmsg_container.fbs +++ b/src/msg/fbuf/p2pmsg_container.fbs @@ -3,7 +3,7 @@ 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 fbschema.p2pmsg; +namespace msg.fbuf.p2pmsg; table Container { //root type for message version:uint16; diff --git a/src/fbschema/p2pmsg_container_generated.h b/src/msg/fbuf/p2pmsg_container_generated.h similarity index 85% rename from src/fbschema/p2pmsg_container_generated.h rename to src/msg/fbuf/p2pmsg_container_generated.h index 4d0b995a..16745a1e 100644 --- a/src/fbschema/p2pmsg_container_generated.h +++ b/src/msg/fbuf/p2pmsg_container_generated.h @@ -1,20 +1,23 @@ // automatically generated by the FlatBuffers compiler, do not modify -#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_ -#define FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_ +#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 fbschema { +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, @@ -76,6 +79,7 @@ struct Container FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { }; struct ContainerBuilder { + typedef Container Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_version(uint16_t version) { @@ -100,7 +104,6 @@ struct ContainerBuilder { : fbb_(_fbb) { start_ = fbb_.StartTable(); } - ContainerBuilder &operator=(const ContainerBuilder &); flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); @@ -138,7 +141,7 @@ inline flatbuffers::Offset CreateContainerDirect( auto lcl__ = lcl ? _fbb.CreateVector(*lcl) : 0; auto signature__ = signature ? _fbb.CreateVector(*signature) : 0; auto content__ = content ? _fbb.CreateVector(*content) : 0; - return fbschema::p2pmsg::CreateContainer( + return msg::fbuf::p2pmsg::CreateContainer( _fbb, version, timestamp, @@ -148,12 +151,12 @@ inline flatbuffers::Offset CreateContainerDirect( content__); } -inline const fbschema::p2pmsg::Container *GetContainer(const void *buf) { - return flatbuffers::GetRoot(buf); +inline const msg::fbuf::p2pmsg::Container *GetContainer(const void *buf) { + return flatbuffers::GetRoot(buf); } -inline const fbschema::p2pmsg::Container *GetSizePrefixedContainer(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); +inline const msg::fbuf::p2pmsg::Container *GetSizePrefixedContainer(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); } inline Container *GetMutableContainer(void *buf) { @@ -162,27 +165,28 @@ inline Container *GetMutableContainer(void *buf) { inline bool VerifyContainerBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); + return verifier.VerifyBuffer(nullptr); } inline bool VerifySizePrefixedContainerBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); + return verifier.VerifySizePrefixedBuffer(nullptr); } inline void FinishContainerBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.Finish(root); } inline void FinishSizePrefixedContainerBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.FinishSizePrefixed(root); } } // namespace p2pmsg -} // namespace fbschema +} // namespace fbuf +} // namespace msg -#endif // FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_ +#endif // FLATBUFFERS_GENERATED_P2PMSGCONTAINER_MSG_FBUF_P2PMSG_H_ diff --git a/src/fbschema/p2pmsg_content.fbs b/src/msg/fbuf/p2pmsg_content.fbs similarity index 87% rename from src/fbschema/p2pmsg_content.fbs rename to src/msg/fbuf/p2pmsg_content.fbs index 72cce89b..76ca452c 100644 --- a/src/fbschema/p2pmsg_content.fbs +++ b/src/msg/fbuf/p2pmsg_content.fbs @@ -1,8 +1,8 @@ // IDL file for p2p message content schema. -// flatc -o src/fbschema/ --gen-mutable --cpp src/fbschema/p2pmsg_content.fbs +// flatc -o src/msg/fbuf/ --gen-mutable --cpp src/msg/fbuf/p2pmsg_content.fbs include "common_schema.fbs"; -namespace fbschema.p2pmsg; +namespace msg.fbuf.p2pmsg; table Peer_Challenge_Message { challenge:[ubyte]; @@ -13,14 +13,15 @@ table Peer_Challenge_Response_Message { sig:[ubyte]; } -table UserSubmittedMessage { - content:[ubyte]; +table UserInput { + input_container:[ubyte]; signature:[ubyte]; + protocol:uint8; } -table UserSubmittedMessageGroup { +table UserInputGroup { pubkey:[ubyte]; - messages:[UserSubmittedMessage]; + messages:[UserInput]; } union Message { Peer_Challenge_Response_Message, Peer_Challenge_Message, NonUnl_Proposal_Message, Proposal_Message, Npl_Message, State_Request_Message, State_Response_Message, History_Request_Message, History_Response_Message } //message content type @@ -30,7 +31,7 @@ table Content { } table NonUnl_Proposal_Message { - usermessages:[UserSubmittedMessageGroup]; + user_inputs:[UserInputGroup]; } table Proposal_Message { //Proposal type message schema diff --git a/src/fbschema/p2pmsg_content_generated.h b/src/msg/fbuf/p2pmsg_content_generated.h similarity index 75% rename from src/fbschema/p2pmsg_content_generated.h rename to src/msg/fbuf/p2pmsg_content_generated.h index 94bda478..bd620de3 100644 --- a/src/fbschema/p2pmsg_content_generated.h +++ b/src/msg/fbuf/p2pmsg_content_generated.h @@ -1,14 +1,15 @@ // automatically generated by the FlatBuffers compiler, do not modify -#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_ -#define FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_ +#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 fbschema { +namespace msg { +namespace fbuf { namespace p2pmsg { struct Peer_Challenge_Message; @@ -17,11 +18,11 @@ struct Peer_Challenge_MessageBuilder; struct Peer_Challenge_Response_Message; struct Peer_Challenge_Response_MessageBuilder; -struct UserSubmittedMessage; -struct UserSubmittedMessageBuilder; +struct UserInput; +struct UserInputBuilder; -struct UserSubmittedMessageGroup; -struct UserSubmittedMessageGroupBuilder; +struct UserInputGroup; +struct UserInputGroupBuilder; struct Content; struct ContentBuilder; @@ -123,39 +124,39 @@ template struct MessageTraits { static const Message enum_value = Message_NONE; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_Peer_Challenge_Response_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_Peer_Challenge_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_NonUnl_Proposal_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_Proposal_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_Npl_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_State_Request_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_State_Response_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_History_Request_Message; }; -template<> struct MessageTraits { +template<> struct MessageTraits { static const Message enum_value = Message_History_Response_Message; }; @@ -235,15 +236,15 @@ template struct State_ResponseTraits { static const State_Response enum_value = State_Response_NONE; }; -template<> struct State_ResponseTraits { +template<> struct State_ResponseTraits { static const State_Response enum_value = State_Response_File_HashMap_Response; }; -template<> struct State_ResponseTraits { +template<> struct State_ResponseTraits { static const State_Response enum_value = State_Response_Block_Response; }; -template<> struct State_ResponseTraits { +template<> struct State_ResponseTraits { static const State_Response enum_value = State_Response_Fs_Entry_Response; }; @@ -299,7 +300,7 @@ inline flatbuffers::Offset CreatePeer_Challenge_MessageD flatbuffers::FlatBufferBuilder &_fbb, const std::vector *challenge = nullptr) { auto challenge__ = challenge ? _fbb.CreateVector(*challenge) : 0; - return fbschema::p2pmsg::CreatePeer_Challenge_Message( + return msg::fbuf::p2pmsg::CreatePeer_Challenge_Message( _fbb, challenge__); } @@ -369,23 +370,24 @@ inline flatbuffers::Offset CreatePeer_Challenge const std::vector *sig = nullptr) { auto challenge__ = challenge ? _fbb.CreateVector(*challenge) : 0; auto sig__ = sig ? _fbb.CreateVector(*sig) : 0; - return fbschema::p2pmsg::CreatePeer_Challenge_Response_Message( + return msg::fbuf::p2pmsg::CreatePeer_Challenge_Response_Message( _fbb, challenge__, sig__); } -struct UserSubmittedMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UserSubmittedMessageBuilder Builder; +struct UserInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UserInputBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CONTENT = 4, - VT_SIGNATURE = 6 + VT_INPUT_CONTAINER = 4, + VT_SIGNATURE = 6, + VT_PROTOCOL = 8 }; - const flatbuffers::Vector *content() const { - return GetPointer *>(VT_CONTENT); + const flatbuffers::Vector *input_container() const { + return GetPointer *>(VT_INPUT_CONTAINER); } - flatbuffers::Vector *mutable_content() { - return GetPointer *>(VT_CONTENT); + flatbuffers::Vector *mutable_input_container() { + return GetPointer *>(VT_INPUT_CONTAINER); } const flatbuffers::Vector *signature() const { return GetPointer *>(VT_SIGNATURE); @@ -393,61 +395,75 @@ struct UserSubmittedMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table 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_CONTENT) && - verifier.VerifyVector(content()) && + VerifyOffset(verifier, VT_INPUT_CONTAINER) && + verifier.VerifyVector(input_container()) && VerifyOffset(verifier, VT_SIGNATURE) && verifier.VerifyVector(signature()) && + VerifyField(verifier, VT_PROTOCOL) && verifier.EndTable(); } }; -struct UserSubmittedMessageBuilder { - typedef UserSubmittedMessage Table; +struct UserInputBuilder { + typedef UserInput Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_content(flatbuffers::Offset> content) { - fbb_.AddOffset(UserSubmittedMessage::VT_CONTENT, content); + void add_input_container(flatbuffers::Offset> input_container) { + fbb_.AddOffset(UserInput::VT_INPUT_CONTAINER, input_container); } void add_signature(flatbuffers::Offset> signature) { - fbb_.AddOffset(UserSubmittedMessage::VT_SIGNATURE, signature); + fbb_.AddOffset(UserInput::VT_SIGNATURE, signature); } - explicit UserSubmittedMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) + 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() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUserSubmittedMessage( +inline flatbuffers::Offset CreateUserInput( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> content = 0, - flatbuffers::Offset> signature = 0) { - UserSubmittedMessageBuilder builder_(_fbb); + flatbuffers::Offset> input_container = 0, + flatbuffers::Offset> signature = 0, + uint8_t protocol = 0) { + UserInputBuilder builder_(_fbb); builder_.add_signature(signature); - builder_.add_content(content); + builder_.add_input_container(input_container); + builder_.add_protocol(protocol); return builder_.Finish(); } -inline flatbuffers::Offset CreateUserSubmittedMessageDirect( +inline flatbuffers::Offset CreateUserInputDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *content = nullptr, - const std::vector *signature = nullptr) { - auto content__ = content ? _fbb.CreateVector(*content) : 0; + 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 fbschema::p2pmsg::CreateUserSubmittedMessage( + return msg::fbuf::p2pmsg::CreateUserInput( _fbb, - content__, - signature__); + input_container__, + signature__, + protocol); } -struct UserSubmittedMessageGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UserSubmittedMessageGroupBuilder Builder; +struct UserInputGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UserInputGroupBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PUBKEY = 4, VT_MESSAGES = 6 @@ -458,11 +474,11 @@ struct UserSubmittedMessageGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers:: flatbuffers::Vector *mutable_pubkey() { return GetPointer *>(VT_PUBKEY); } - const flatbuffers::Vector> *messages() const { - return GetPointer> *>(VT_MESSAGES); + const flatbuffers::Vector> *messages() const { + return GetPointer> *>(VT_MESSAGES); } - flatbuffers::Vector> *mutable_messages() { - return GetPointer> *>(VT_MESSAGES); + flatbuffers::Vector> *mutable_messages() { + return GetPointer> *>(VT_MESSAGES); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -475,44 +491,44 @@ struct UserSubmittedMessageGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers:: } }; -struct UserSubmittedMessageGroupBuilder { - typedef UserSubmittedMessageGroup Table; +struct UserInputGroupBuilder { + typedef UserInputGroup Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_pubkey(flatbuffers::Offset> pubkey) { - fbb_.AddOffset(UserSubmittedMessageGroup::VT_PUBKEY, pubkey); + fbb_.AddOffset(UserInputGroup::VT_PUBKEY, pubkey); } - void add_messages(flatbuffers::Offset>> messages) { - fbb_.AddOffset(UserSubmittedMessageGroup::VT_MESSAGES, messages); + void add_messages(flatbuffers::Offset>> messages) { + fbb_.AddOffset(UserInputGroup::VT_MESSAGES, messages); } - explicit UserSubmittedMessageGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit UserInputGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUserSubmittedMessageGroup( +inline flatbuffers::Offset CreateUserInputGroup( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset> pubkey = 0, - flatbuffers::Offset>> messages = 0) { - UserSubmittedMessageGroupBuilder builder_(_fbb); + flatbuffers::Offset>> messages = 0) { + UserInputGroupBuilder builder_(_fbb); builder_.add_messages(messages); builder_.add_pubkey(pubkey); return builder_.Finish(); } -inline flatbuffers::Offset CreateUserSubmittedMessageGroupDirect( +inline flatbuffers::Offset CreateUserInputGroupDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector *pubkey = nullptr, - const std::vector> *messages = nullptr) { + const std::vector> *messages = nullptr) { auto pubkey__ = pubkey ? _fbb.CreateVector(*pubkey) : 0; - auto messages__ = messages ? _fbb.CreateVector>(*messages) : 0; - return fbschema::p2pmsg::CreateUserSubmittedMessageGroup( + auto messages__ = messages ? _fbb.CreateVector>(*messages) : 0; + return msg::fbuf::p2pmsg::CreateUserInputGroup( _fbb, pubkey__, messages__); @@ -524,39 +540,39 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_MESSAGE_TYPE = 4, VT_MESSAGE = 6 }; - fbschema::p2pmsg::Message message_type() const { - return static_cast(GetField(VT_MESSAGE_TYPE, 0)); + 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 fbschema::p2pmsg::Peer_Challenge_Response_Message *message_as_Peer_Challenge_Response_Message() const { - return message_type() == fbschema::p2pmsg::Message_Peer_Challenge_Response_Message ? static_cast(message()) : nullptr; + 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 fbschema::p2pmsg::Peer_Challenge_Message *message_as_Peer_Challenge_Message() const { - return message_type() == fbschema::p2pmsg::Message_Peer_Challenge_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 fbschema::p2pmsg::NonUnl_Proposal_Message *message_as_NonUnl_Proposal_Message() const { - return message_type() == fbschema::p2pmsg::Message_NonUnl_Proposal_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 fbschema::p2pmsg::Proposal_Message *message_as_Proposal_Message() const { - return message_type() == fbschema::p2pmsg::Message_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 fbschema::p2pmsg::Npl_Message *message_as_Npl_Message() const { - return message_type() == fbschema::p2pmsg::Message_Npl_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 fbschema::p2pmsg::State_Request_Message *message_as_State_Request_Message() const { - return message_type() == fbschema::p2pmsg::Message_State_Request_Message ? static_cast(message()) : nullptr; + const msg::fbuf::p2pmsg::State_Request_Message *message_as_State_Request_Message() const { + return message_type() == msg::fbuf::p2pmsg::Message_State_Request_Message ? static_cast(message()) : nullptr; } - const fbschema::p2pmsg::State_Response_Message *message_as_State_Response_Message() const { - return message_type() == fbschema::p2pmsg::Message_State_Response_Message ? static_cast(message()) : nullptr; + const msg::fbuf::p2pmsg::State_Response_Message *message_as_State_Response_Message() const { + return message_type() == msg::fbuf::p2pmsg::Message_State_Response_Message ? static_cast(message()) : nullptr; } - const fbschema::p2pmsg::History_Request_Message *message_as_History_Request_Message() const { - return message_type() == fbschema::p2pmsg::Message_History_Request_Message ? static_cast(message()) : nullptr; + const msg::fbuf::p2pmsg::History_Request_Message *message_as_History_Request_Message() const { + return message_type() == msg::fbuf::p2pmsg::Message_History_Request_Message ? static_cast(message()) : nullptr; } - const fbschema::p2pmsg::History_Response_Message *message_as_History_Response_Message() const { - return message_type() == fbschema::p2pmsg::Message_History_Response_Message ? static_cast(message()) : nullptr; + const msg::fbuf::p2pmsg::History_Response_Message *message_as_History_Response_Message() const { + return message_type() == msg::fbuf::p2pmsg::Message_History_Response_Message ? static_cast(message()) : nullptr; } void *mutable_message() { return GetPointer(VT_MESSAGE); @@ -570,39 +586,39 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { } }; -template<> inline const fbschema::p2pmsg::Peer_Challenge_Response_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *Content::message_as() const { return message_as_Peer_Challenge_Response_Message(); } -template<> inline const fbschema::p2pmsg::Peer_Challenge_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::Peer_Challenge_Message *Content::message_as() const { return message_as_Peer_Challenge_Message(); } -template<> inline const fbschema::p2pmsg::NonUnl_Proposal_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *Content::message_as() const { return message_as_NonUnl_Proposal_Message(); } -template<> inline const fbschema::p2pmsg::Proposal_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::Proposal_Message *Content::message_as() const { return message_as_Proposal_Message(); } -template<> inline const fbschema::p2pmsg::Npl_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::Npl_Message *Content::message_as() const { return message_as_Npl_Message(); } -template<> inline const fbschema::p2pmsg::State_Request_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::State_Request_Message *Content::message_as() const { return message_as_State_Request_Message(); } -template<> inline const fbschema::p2pmsg::State_Response_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::State_Response_Message *Content::message_as() const { return message_as_State_Response_Message(); } -template<> inline const fbschema::p2pmsg::History_Request_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::History_Request_Message *Content::message_as() const { return message_as_History_Request_Message(); } -template<> inline const fbschema::p2pmsg::History_Response_Message *Content::message_as() const { +template<> inline const msg::fbuf::p2pmsg::History_Response_Message *Content::message_as() const { return message_as_History_Response_Message(); } @@ -610,7 +626,7 @@ struct ContentBuilder { typedef Content Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_message_type(fbschema::p2pmsg::Message message_type) { + 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) { @@ -629,7 +645,7 @@ struct ContentBuilder { inline flatbuffers::Offset CreateContent( flatbuffers::FlatBufferBuilder &_fbb, - fbschema::p2pmsg::Message message_type = fbschema::p2pmsg::Message_NONE, + msg::fbuf::p2pmsg::Message message_type = msg::fbuf::p2pmsg::Message_NONE, flatbuffers::Offset message = 0) { ContentBuilder builder_(_fbb); builder_.add_message(message); @@ -640,19 +656,19 @@ inline flatbuffers::Offset CreateContent( struct NonUnl_Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef NonUnl_Proposal_MessageBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_USERMESSAGES = 4 + VT_USER_INPUTS = 4 }; - const flatbuffers::Vector> *usermessages() const { - return GetPointer> *>(VT_USERMESSAGES); + const flatbuffers::Vector> *user_inputs() const { + return GetPointer> *>(VT_USER_INPUTS); } - flatbuffers::Vector> *mutable_usermessages() { - return GetPointer> *>(VT_USERMESSAGES); + flatbuffers::Vector> *mutable_user_inputs() { + return GetPointer> *>(VT_USER_INPUTS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_USERMESSAGES) && - verifier.VerifyVector(usermessages()) && - verifier.VerifyVectorOfTables(usermessages()) && + VerifyOffset(verifier, VT_USER_INPUTS) && + verifier.VerifyVector(user_inputs()) && + verifier.VerifyVectorOfTables(user_inputs()) && verifier.EndTable(); } }; @@ -661,8 +677,8 @@ struct NonUnl_Proposal_MessageBuilder { typedef NonUnl_Proposal_Message Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_usermessages(flatbuffers::Offset>> usermessages) { - fbb_.AddOffset(NonUnl_Proposal_Message::VT_USERMESSAGES, usermessages); + 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) { @@ -677,19 +693,19 @@ struct NonUnl_Proposal_MessageBuilder { inline flatbuffers::Offset CreateNonUnl_Proposal_Message( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> usermessages = 0) { + flatbuffers::Offset>> user_inputs = 0) { NonUnl_Proposal_MessageBuilder builder_(_fbb); - builder_.add_usermessages(usermessages); + builder_.add_user_inputs(user_inputs); return builder_.Finish(); } inline flatbuffers::Offset CreateNonUnl_Proposal_MessageDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *usermessages = nullptr) { - auto usermessages__ = usermessages ? _fbb.CreateVector>(*usermessages) : 0; - return fbschema::p2pmsg::CreateNonUnl_Proposal_Message( + const std::vector> *user_inputs = nullptr) { + auto user_inputs__ = user_inputs ? _fbb.CreateVector>(*user_inputs) : 0; + return msg::fbuf::p2pmsg::CreateNonUnl_Proposal_Message( _fbb, - usermessages__); + user_inputs__); } struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -714,23 +730,23 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool mutate_time(uint64_t _time) { return SetField(VT_TIME, _time, 0); } - const flatbuffers::Vector> *users() const { - return GetPointer> *>(VT_USERS); + const flatbuffers::Vector> *users() const { + return GetPointer> *>(VT_USERS); } - flatbuffers::Vector> *mutable_users() { - return GetPointer> *>(VT_USERS); + flatbuffers::Vector> *mutable_users() { + return GetPointer> *>(VT_USERS); } - const flatbuffers::Vector> *hash_inputs() const { - return GetPointer> *>(VT_HASH_INPUTS); + const flatbuffers::Vector> *hash_inputs() const { + return GetPointer> *>(VT_HASH_INPUTS); } - flatbuffers::Vector> *mutable_hash_inputs() { - return GetPointer> *>(VT_HASH_INPUTS); + flatbuffers::Vector> *mutable_hash_inputs() { + return GetPointer> *>(VT_HASH_INPUTS); } - const flatbuffers::Vector> *hash_outputs() const { - return GetPointer> *>(VT_HASH_OUTPUTS); + const flatbuffers::Vector> *hash_outputs() const { + return GetPointer> *>(VT_HASH_OUTPUTS); } - flatbuffers::Vector> *mutable_hash_outputs() { - return GetPointer> *>(VT_HASH_OUTPUTS); + flatbuffers::Vector> *mutable_hash_outputs() { + return GetPointer> *>(VT_HASH_OUTPUTS); } const flatbuffers::Vector *state() const { return GetPointer *>(VT_STATE); @@ -767,13 +783,13 @@ struct Proposal_MessageBuilder { void add_time(uint64_t time) { fbb_.AddElement(Proposal_Message::VT_TIME, time, 0); } - void add_users(flatbuffers::Offset>> users) { + void add_users(flatbuffers::Offset>> users) { fbb_.AddOffset(Proposal_Message::VT_USERS, users); } - void add_hash_inputs(flatbuffers::Offset>> hash_inputs) { + void add_hash_inputs(flatbuffers::Offset>> hash_inputs) { fbb_.AddOffset(Proposal_Message::VT_HASH_INPUTS, hash_inputs); } - void add_hash_outputs(flatbuffers::Offset>> hash_outputs) { + void add_hash_outputs(flatbuffers::Offset>> hash_outputs) { fbb_.AddOffset(Proposal_Message::VT_HASH_OUTPUTS, hash_outputs); } void add_state(flatbuffers::Offset> state) { @@ -794,9 +810,9 @@ inline flatbuffers::Offset CreateProposal_Message( flatbuffers::FlatBufferBuilder &_fbb, uint8_t stage = 0, uint64_t time = 0, - flatbuffers::Offset>> users = 0, - flatbuffers::Offset>> hash_inputs = 0, - flatbuffers::Offset>> hash_outputs = 0, + flatbuffers::Offset>> users = 0, + flatbuffers::Offset>> hash_inputs = 0, + flatbuffers::Offset>> hash_outputs = 0, flatbuffers::Offset> state = 0) { Proposal_MessageBuilder builder_(_fbb); builder_.add_time(time); @@ -812,15 +828,15 @@ inline flatbuffers::Offset CreateProposal_MessageDirect( flatbuffers::FlatBufferBuilder &_fbb, uint8_t stage = 0, uint64_t time = 0, - const std::vector> *users = nullptr, - const std::vector> *hash_inputs = nullptr, - const std::vector> *hash_outputs = nullptr, + const std::vector> *users = nullptr, + const std::vector> *hash_inputs = nullptr, + const std::vector> *hash_outputs = nullptr, const std::vector *state = nullptr) { - auto users__ = users ? _fbb.CreateVector>(*users) : 0; - auto hash_inputs__ = hash_inputs ? _fbb.CreateVector>(*hash_inputs) : 0; - auto hash_outputs__ = hash_outputs ? _fbb.CreateVector>(*hash_outputs) : 0; + auto users__ = users ? _fbb.CreateVector>(*users) : 0; + auto hash_inputs__ = hash_inputs ? _fbb.CreateVector>(*hash_inputs) : 0; + auto hash_outputs__ = hash_outputs ? _fbb.CreateVector>(*hash_outputs) : 0; auto state__ = state ? _fbb.CreateVector(*state) : 0; - return fbschema::p2pmsg::CreateProposal_Message( + return msg::fbuf::p2pmsg::CreateProposal_Message( _fbb, stage, time, @@ -879,7 +895,7 @@ inline flatbuffers::Offset CreateNpl_MessageDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector *data = nullptr) { auto data__ = data ? _fbb.CreateVector(*data) : 0; - return fbschema::p2pmsg::CreateNpl_Message( + return msg::fbuf::p2pmsg::CreateNpl_Message( _fbb, data__); } @@ -949,7 +965,7 @@ inline flatbuffers::Offset CreateHistory_Request_Messag const std::vector *required_lcl = nullptr) { auto minimum_lcl__ = minimum_lcl ? _fbb.CreateVector(*minimum_lcl) : 0; auto required_lcl__ = required_lcl ? _fbb.CreateVector(*required_lcl) : 0; - return fbschema::p2pmsg::CreateHistory_Request_Message( + return msg::fbuf::p2pmsg::CreateHistory_Request_Message( _fbb, minimum_lcl__, required_lcl__); @@ -961,16 +977,16 @@ struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::T VT_HIST_LEDGERS = 4, VT_ERROR = 6 }; - const flatbuffers::Vector> *hist_ledgers() const { - return GetPointer> *>(VT_HIST_LEDGERS); + const flatbuffers::Vector> *hist_ledgers() const { + return GetPointer> *>(VT_HIST_LEDGERS); } - flatbuffers::Vector> *mutable_hist_ledgers() { - return GetPointer> *>(VT_HIST_LEDGERS); + flatbuffers::Vector> *mutable_hist_ledgers() { + return GetPointer> *>(VT_HIST_LEDGERS); } - fbschema::p2pmsg::Ledger_Response_Error error() const { - return static_cast(GetField(VT_ERROR, 0)); + msg::fbuf::p2pmsg::Ledger_Response_Error error() const { + return static_cast(GetField(VT_ERROR, 0)); } - bool mutate_error(fbschema::p2pmsg::Ledger_Response_Error _error) { + bool mutate_error(msg::fbuf::p2pmsg::Ledger_Response_Error _error) { return SetField(VT_ERROR, static_cast(_error), 0); } bool Verify(flatbuffers::Verifier &verifier) const { @@ -987,10 +1003,10 @@ struct History_Response_MessageBuilder { typedef History_Response_Message Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_hist_ledgers(flatbuffers::Offset>> hist_ledgers) { + void add_hist_ledgers(flatbuffers::Offset>> hist_ledgers) { fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGERS, hist_ledgers); } - void add_error(fbschema::p2pmsg::Ledger_Response_Error error) { + void add_error(msg::fbuf::p2pmsg::Ledger_Response_Error error) { fbb_.AddElement(History_Response_Message::VT_ERROR, static_cast(error), 0); } explicit History_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1006,8 +1022,8 @@ struct History_Response_MessageBuilder { inline flatbuffers::Offset CreateHistory_Response_Message( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> hist_ledgers = 0, - fbschema::p2pmsg::Ledger_Response_Error error = fbschema::p2pmsg::Ledger_Response_Error_None) { + flatbuffers::Offset>> hist_ledgers = 0, + msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) { History_Response_MessageBuilder builder_(_fbb); builder_.add_hist_ledgers(hist_ledgers); builder_.add_error(error); @@ -1016,10 +1032,10 @@ inline flatbuffers::Offset CreateHistory_Response_Mess inline flatbuffers::Offset CreateHistory_Response_MessageDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *hist_ledgers = nullptr, - fbschema::p2pmsg::Ledger_Response_Error error = fbschema::p2pmsg::Ledger_Response_Error_None) { - auto hist_ledgers__ = hist_ledgers ? _fbb.CreateVector>(*hist_ledgers) : 0; - return fbschema::p2pmsg::CreateHistory_Response_Message( + const std::vector> *hist_ledgers = nullptr, + msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) { + auto hist_ledgers__ = hist_ledgers ? _fbb.CreateVector>(*hist_ledgers) : 0; + return msg::fbuf::p2pmsg::CreateHistory_Response_Message( _fbb, hist_ledgers__, error); @@ -1037,11 +1053,11 @@ struct HistoryLedgerPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool mutate_seq_no(uint64_t _seq_no) { return SetField(VT_SEQ_NO, _seq_no, 0); } - const fbschema::p2pmsg::HistoryLedger *ledger() const { - return GetPointer(VT_LEDGER); + const msg::fbuf::p2pmsg::HistoryLedger *ledger() const { + return GetPointer(VT_LEDGER); } - fbschema::p2pmsg::HistoryLedger *mutable_ledger() { - return GetPointer(VT_LEDGER); + msg::fbuf::p2pmsg::HistoryLedger *mutable_ledger() { + return GetPointer(VT_LEDGER); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -1059,7 +1075,7 @@ struct HistoryLedgerPairBuilder { void add_seq_no(uint64_t seq_no) { fbb_.AddElement(HistoryLedgerPair::VT_SEQ_NO, seq_no, 0); } - void add_ledger(flatbuffers::Offset ledger) { + void add_ledger(flatbuffers::Offset ledger) { fbb_.AddOffset(HistoryLedgerPair::VT_LEDGER, ledger); } explicit HistoryLedgerPairBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1076,7 +1092,7 @@ struct HistoryLedgerPairBuilder { inline flatbuffers::Offset CreateHistoryLedgerPair( flatbuffers::FlatBufferBuilder &_fbb, uint64_t seq_no = 0, - flatbuffers::Offset ledger = 0) { + flatbuffers::Offset ledger = 0) { HistoryLedgerPairBuilder builder_(_fbb); builder_.add_seq_no(seq_no); builder_.add_ledger(ledger); @@ -1164,7 +1180,7 @@ inline flatbuffers::Offset CreateHistoryLedgerDirect( auto state__ = state ? _fbb.CreateVector(*state) : 0; auto lcl__ = lcl ? _fbb.CreateVector(*lcl) : 0; auto raw_ledger__ = raw_ledger ? _fbb.CreateVector(*raw_ledger) : 0; - return fbschema::p2pmsg::CreateHistoryLedger( + return msg::fbuf::p2pmsg::CreateHistoryLedger( _fbb, state__, lcl__, @@ -1264,7 +1280,7 @@ inline flatbuffers::Offset CreateState_Request_MessageDir 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 fbschema::p2pmsg::CreateState_Request_Message( + return msg::fbuf::p2pmsg::CreateState_Request_Message( _fbb, parent_path__, is_file, @@ -1280,21 +1296,21 @@ struct State_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VT_HASH = 8, VT_PATH = 10 }; - fbschema::p2pmsg::State_Response state_response_type() const { - return static_cast(GetField(VT_STATE_RESPONSE_TYPE, 0)); + msg::fbuf::p2pmsg::State_Response state_response_type() const { + return static_cast(GetField(VT_STATE_RESPONSE_TYPE, 0)); } const void *state_response() const { return GetPointer(VT_STATE_RESPONSE); } template const T *state_response_as() const; - const fbschema::p2pmsg::File_HashMap_Response *state_response_as_File_HashMap_Response() const { - return state_response_type() == fbschema::p2pmsg::State_Response_File_HashMap_Response ? static_cast(state_response()) : nullptr; + const msg::fbuf::p2pmsg::File_HashMap_Response *state_response_as_File_HashMap_Response() const { + return state_response_type() == msg::fbuf::p2pmsg::State_Response_File_HashMap_Response ? static_cast(state_response()) : nullptr; } - const fbschema::p2pmsg::Block_Response *state_response_as_Block_Response() const { - return state_response_type() == fbschema::p2pmsg::State_Response_Block_Response ? static_cast(state_response()) : nullptr; + const msg::fbuf::p2pmsg::Block_Response *state_response_as_Block_Response() const { + return state_response_type() == msg::fbuf::p2pmsg::State_Response_Block_Response ? static_cast(state_response()) : nullptr; } - const fbschema::p2pmsg::Fs_Entry_Response *state_response_as_Fs_Entry_Response() const { - return state_response_type() == fbschema::p2pmsg::State_Response_Fs_Entry_Response ? static_cast(state_response()) : nullptr; + const msg::fbuf::p2pmsg::Fs_Entry_Response *state_response_as_Fs_Entry_Response() const { + return state_response_type() == msg::fbuf::p2pmsg::State_Response_Fs_Entry_Response ? static_cast(state_response()) : nullptr; } void *mutable_state_response() { return GetPointer(VT_STATE_RESPONSE); @@ -1324,15 +1340,15 @@ struct State_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab } }; -template<> inline const fbschema::p2pmsg::File_HashMap_Response *State_Response_Message::state_response_as() const { +template<> inline const msg::fbuf::p2pmsg::File_HashMap_Response *State_Response_Message::state_response_as() const { return state_response_as_File_HashMap_Response(); } -template<> inline const fbschema::p2pmsg::Block_Response *State_Response_Message::state_response_as() const { +template<> inline const msg::fbuf::p2pmsg::Block_Response *State_Response_Message::state_response_as() const { return state_response_as_Block_Response(); } -template<> inline const fbschema::p2pmsg::Fs_Entry_Response *State_Response_Message::state_response_as() const { +template<> inline const msg::fbuf::p2pmsg::Fs_Entry_Response *State_Response_Message::state_response_as() const { return state_response_as_Fs_Entry_Response(); } @@ -1340,7 +1356,7 @@ struct State_Response_MessageBuilder { typedef State_Response_Message Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_state_response_type(fbschema::p2pmsg::State_Response state_response_type) { + void add_state_response_type(msg::fbuf::p2pmsg::State_Response state_response_type) { fbb_.AddElement(State_Response_Message::VT_STATE_RESPONSE_TYPE, static_cast(state_response_type), 0); } void add_state_response(flatbuffers::Offset state_response) { @@ -1365,7 +1381,7 @@ struct State_Response_MessageBuilder { inline flatbuffers::Offset CreateState_Response_Message( flatbuffers::FlatBufferBuilder &_fbb, - fbschema::p2pmsg::State_Response state_response_type = fbschema::p2pmsg::State_Response_NONE, + msg::fbuf::p2pmsg::State_Response state_response_type = msg::fbuf::p2pmsg::State_Response_NONE, flatbuffers::Offset state_response = 0, flatbuffers::Offset> hash = 0, flatbuffers::Offset path = 0) { @@ -1379,13 +1395,13 @@ inline flatbuffers::Offset CreateState_Response_Message( inline flatbuffers::Offset CreateState_Response_MessageDirect( flatbuffers::FlatBufferBuilder &_fbb, - fbschema::p2pmsg::State_Response state_response_type = fbschema::p2pmsg::State_Response_NONE, + msg::fbuf::p2pmsg::State_Response state_response_type = msg::fbuf::p2pmsg::State_Response_NONE, flatbuffers::Offset state_response = 0, const std::vector *hash = nullptr, const char *path = nullptr) { auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; auto path__ = path ? _fbb.CreateString(path) : 0; - return fbschema::p2pmsg::CreateState_Response_Message( + return msg::fbuf::p2pmsg::CreateState_Response_Message( _fbb, state_response_type, state_response, @@ -1398,11 +1414,11 @@ struct Fs_Entry_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ENTRIES = 4 }; - const flatbuffers::Vector> *entries() const { - return GetPointer> *>(VT_ENTRIES); + const flatbuffers::Vector> *entries() const { + return GetPointer> *>(VT_ENTRIES); } - flatbuffers::Vector> *mutable_entries() { - return GetPointer> *>(VT_ENTRIES); + flatbuffers::Vector> *mutable_entries() { + return GetPointer> *>(VT_ENTRIES); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -1417,7 +1433,7 @@ struct Fs_Entry_ResponseBuilder { typedef Fs_Entry_Response Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_entries(flatbuffers::Offset>> entries) { + void add_entries(flatbuffers::Offset>> entries) { fbb_.AddOffset(Fs_Entry_Response::VT_ENTRIES, entries); } explicit Fs_Entry_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1433,7 +1449,7 @@ struct Fs_Entry_ResponseBuilder { inline flatbuffers::Offset CreateFs_Entry_Response( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> entries = 0) { + flatbuffers::Offset>> entries = 0) { Fs_Entry_ResponseBuilder builder_(_fbb); builder_.add_entries(entries); return builder_.Finish(); @@ -1441,9 +1457,9 @@ inline flatbuffers::Offset CreateFs_Entry_Response( inline flatbuffers::Offset CreateFs_Entry_ResponseDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *entries = nullptr) { - auto entries__ = entries ? _fbb.CreateVector>(*entries) : 0; - return fbschema::p2pmsg::CreateFs_Entry_Response( + const std::vector> *entries = nullptr) { + auto entries__ = entries ? _fbb.CreateVector>(*entries) : 0; + return msg::fbuf::p2pmsg::CreateFs_Entry_Response( _fbb, entries__); } @@ -1511,7 +1527,7 @@ inline flatbuffers::Offset CreateFile_HashMap_ResponseDir uint64_t file_length = 0, const std::vector *hash_map = nullptr) { auto hash_map__ = hash_map ? _fbb.CreateVector(*hash_map) : 0; - return fbschema::p2pmsg::CreateFile_HashMap_Response( + return msg::fbuf::p2pmsg::CreateFile_HashMap_Response( _fbb, file_length, hash_map__); @@ -1580,7 +1596,7 @@ inline flatbuffers::Offset CreateBlock_ResponseDirect( uint32_t block_id = 0, const std::vector *data = nullptr) { auto data__ = data ? _fbb.CreateVector(*data) : 0; - return fbschema::p2pmsg::CreateBlock_Response( + return msg::fbuf::p2pmsg::CreateBlock_Response( _fbb, block_id, data__); @@ -1665,7 +1681,7 @@ inline flatbuffers::Offset CreateState_FS_Hash_EntryDirect( const std::vector *hash = nullptr) { auto name__ = name ? _fbb.CreateString(name) : 0; auto hash__ = hash ? _fbb.CreateVector(*hash) : 0; - return fbschema::p2pmsg::CreateState_FS_Hash_Entry( + return msg::fbuf::p2pmsg::CreateState_FS_Hash_Entry( _fbb, name__, is_file, @@ -1678,39 +1694,39 @@ inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Mess return true; } case Message_Peer_Challenge_Response_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_Peer_Challenge_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_NonUnl_Proposal_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_Proposal_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_Npl_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_State_Request_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_State_Response_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_History_Request_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Message_History_Response_Message: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } default: return true; @@ -1735,15 +1751,15 @@ inline bool VerifyState_Response(flatbuffers::Verifier &verifier, const void *ob return true; } case State_Response_File_HashMap_Response: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case State_Response_Block_Response: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case State_Response_Fs_Entry_Response: { - auto ptr = reinterpret_cast(obj); + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } default: return true; @@ -1762,12 +1778,12 @@ inline bool VerifyState_ResponseVector(flatbuffers::Verifier &verifier, const fl return true; } -inline const fbschema::p2pmsg::Content *GetContent(const void *buf) { - return flatbuffers::GetRoot(buf); +inline const msg::fbuf::p2pmsg::Content *GetContent(const void *buf) { + return flatbuffers::GetRoot(buf); } -inline const fbschema::p2pmsg::Content *GetSizePrefixedContent(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); +inline const msg::fbuf::p2pmsg::Content *GetSizePrefixedContent(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); } inline Content *GetMutableContent(void *buf) { @@ -1776,27 +1792,28 @@ inline Content *GetMutableContent(void *buf) { inline bool VerifyContentBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifyBuffer(nullptr); + return verifier.VerifyBuffer(nullptr); } inline bool VerifySizePrefixedContentBuffer( flatbuffers::Verifier &verifier) { - return verifier.VerifySizePrefixedBuffer(nullptr); + return verifier.VerifySizePrefixedBuffer(nullptr); } inline void FinishContentBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.Finish(root); } inline void FinishSizePrefixedContentBuffer( flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + flatbuffers::Offset root) { fbb.FinishSizePrefixed(root); } } // namespace p2pmsg -} // namespace fbschema +} // namespace fbuf +} // namespace msg -#endif // FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_ +#endif // FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_ diff --git a/src/fbschema/p2pmsg_helpers.cpp b/src/msg/fbuf/p2pmsg_helpers.cpp similarity index 94% rename from src/fbschema/p2pmsg_helpers.cpp rename to src/msg/fbuf/p2pmsg_helpers.cpp index bc98cc93..fc8e8630 100644 --- a/src/fbschema/p2pmsg_helpers.cpp +++ b/src/msg/fbuf/p2pmsg_helpers.cpp @@ -1,17 +1,17 @@ -#include "../pchheader.hpp" -#include "../conf.hpp" -#include "../crypto.hpp" -#include "../util.hpp" -#include "../hplog.hpp" -#include "../p2p/p2p.hpp" -#include "../hpfs/h32.hpp" -#include "../hpfs/hpfs.hpp" +#include "../../pchheader.hpp" +#include "../../conf.hpp" +#include "../../crypto.hpp" +#include "../../util.hpp" +#include "../../hplog.hpp" +#include "../../p2p/p2p.hpp" +#include "../../hpfs/h32.hpp" +#include "../../hpfs/hpfs.hpp" #include "p2pmsg_container_generated.h" #include "p2pmsg_content_generated.h" #include "common_helpers.hpp" #include "p2pmsg_helpers.hpp" -namespace fbschema::p2pmsg +namespace msg::fbuf::p2pmsg { // Length of a peer connection challange. @@ -186,8 +186,8 @@ namespace fbschema::p2pmsg { p2p::nonunl_proposal nup; - if (msg.usermessages()) - nup.user_messages = flatbuf_usermsgsmap_to_usermsgsmap(msg.usermessages()); + if (msg.user_inputs()) + nup.user_inputs = flatbuf_user_input_group_to_user_input_map(msg.user_inputs()); return nup; } @@ -331,7 +331,7 @@ namespace fbschema::p2pmsg const flatbuffers::Offset nupmsg = CreateNonUnl_Proposal_Message( builder, - usermsgsmap_to_flatbuf_usermsgsmap(builder, nup.user_messages)); + 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. @@ -613,23 +613,24 @@ namespace fbschema::p2pmsg //---Conversion helpers from flatbuffers data types to std data types---// - const std::unordered_map> - flatbuf_usermsgsmap_to_usermsgsmap(const flatbuffers::Vector> *fbvec) + const std::unordered_map> + flatbuf_user_input_group_to_user_input_map(const flatbuffers::Vector> *fbvec) { - std::unordered_map> map; + std::unordered_map> map; map.reserve(fbvec->size()); - for (const UserSubmittedMessageGroup *group : *fbvec) + for (const UserInputGroup *group : *fbvec) { - std::list msglist; + std::list user_inputs_list; for (const auto msg : *group->messages()) { - msglist.push_back(usr::user_submitted_message( - flatbuff_bytes_to_sv(msg->content()), - flatbuff_bytes_to_sv(msg->signature()))); + user_inputs_list.push_back(usr::user_input( + flatbuff_bytes_to_sv(msg->input_container()), + flatbuff_bytes_to_sv(msg->signature()), + static_cast(msg->protocol()))); } - map.emplace(flatbuff_bytes_to_sv(group->pubkey()), std::move(msglist)); + map.emplace(flatbuff_bytes_to_sv(group->pubkey()), std::move(user_inputs_list)); } return map; } @@ -637,23 +638,24 @@ namespace fbschema::p2pmsg //---Conversion helpers from std data types to flatbuffers data types---// //---These are used in constructing Flatbuffer messages using builders---// - const flatbuffers::Offset>> - usermsgsmap_to_flatbuf_usermsgsmap(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map) + const flatbuffers::Offset>> + user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map) { - std::vector> fbvec; + std::vector> fbvec; fbvec.reserve(map.size()); for (const auto &[pubkey, msglist] : map) { - std::vector> fbmsgsvec; - for (const usr::user_submitted_message &msg : msglist) + std::vector> fbmsgsvec; + for (const usr::user_input &msg : msglist) { - fbmsgsvec.push_back(CreateUserSubmittedMessage( + fbmsgsvec.push_back(CreateUserInput( builder, - sv_to_flatbuff_bytes(builder, msg.content), - sv_to_flatbuff_bytes(builder, msg.sig))); + sv_to_flatbuff_bytes(builder, msg.input_container), + sv_to_flatbuff_bytes(builder, msg.sig), + static_cast(msg.protocol))); } - fbvec.push_back(CreateUserSubmittedMessageGroup( + fbvec.push_back(CreateUserInputGroup( builder, sv_to_flatbuff_bytes(builder, pubkey), builder.CreateVector(fbmsgsvec))); @@ -668,7 +670,7 @@ namespace fbschema::p2pmsg for (const HistoryLedgerPair *pair : *fbvec) { - std::list msglist; + std::list msglist; p2p::history_ledger ledger; @@ -735,4 +737,4 @@ namespace fbschema::p2pmsg return builder.CreateVector(fbvec); } -} // namespace fbschema::p2pmsg \ No newline at end of file +} // namespace msg::fbuf::p2pmsg \ No newline at end of file diff --git a/src/fbschema/p2pmsg_helpers.hpp b/src/msg/fbuf/p2pmsg_helpers.hpp similarity index 88% rename from src/fbschema/p2pmsg_helpers.hpp rename to src/msg/fbuf/p2pmsg_helpers.hpp index d2b9ffd4..c4fa76dc 100644 --- a/src/fbschema/p2pmsg_helpers.hpp +++ b/src/msg/fbuf/p2pmsg_helpers.hpp @@ -1,14 +1,14 @@ -#ifndef _HP_FBSCHEMA_P2PMSG_HELPERS_ -#define _HP_FBSCHEMA_P2PMSG_HELPERS_ +#ifndef _HP_MSG_FBUF_P2PMSG_HELPERS_ +#define _HP_MSG_FBUF_P2PMSG_HELPERS_ -#include "../pchheader.hpp" +#include "../../pchheader.hpp" +#include "../../p2p/p2p.hpp" +#include "../../hpfs/h32.hpp" +#include "../../hpfs/hpfs.hpp" #include "p2pmsg_container_generated.h" #include "p2pmsg_content_generated.h" -#include "../p2p/p2p.hpp" -#include "../hpfs/h32.hpp" -#include "../hpfs/hpfs.hpp" -namespace fbschema::p2pmsg +namespace msg::fbuf::p2pmsg { /** * This section contains Flatbuffer p2p message reading/writing helpers. @@ -70,13 +70,13 @@ namespace fbschema::p2pmsg //---Conversion helpers from flatbuffers data types to std data types---// - const std::unordered_map> - flatbuf_usermsgsmap_to_usermsgsmap(const flatbuffers::Vector> *fbvec); + 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>> - usermsgsmap_to_flatbuf_usermsgsmap(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map); + const flatbuffers::Offset>> + user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map> &map); const std::map flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector> *fbvec); @@ -95,6 +95,6 @@ namespace fbschema::p2pmsg flatbuffers::FlatBufferBuilder &builder, std::vector &hash_nodes); -} // namespace fbschema::p2pmsg +} // namespace msg::fbuf::p2pmsg #endif \ No newline at end of file diff --git a/src/jsonschema/usrmsg_helpers.cpp b/src/msg/json/usrmsg_json.cpp similarity index 59% rename from src/jsonschema/usrmsg_helpers.cpp rename to src/msg/json/usrmsg_json.cpp index 068e5885..f983b9a2 100644 --- a/src/jsonschema/usrmsg_helpers.cpp +++ b/src/msg/json/usrmsg_json.cpp @@ -1,36 +1,25 @@ -#include "../pchheader.hpp" -#include "../util.hpp" -#include "../crypto.hpp" -#include "../cons/cons.hpp" -#include "../hplog.hpp" -#include "usrmsg_helpers.hpp" +#include "../../pchheader.hpp" +#include "../../util.hpp" +#include "../../crypto.hpp" +#include "../../cons/cons.hpp" +#include "../../hplog.hpp" +#include "../usrmsg_common.hpp" +#include "usrmsg_json.hpp" -namespace jsonschema::usrmsg +namespace msg::usrmsg::json { - // Separators + // JSON separators constexpr const char *SEP_COMMA = "\",\""; constexpr const char *SEP_COLON = "\":\""; constexpr const char *SEP_COMMA_NOQUOTE = ",\""; constexpr const char *SEP_COLON_NOQUOTE = "\":"; - // Message field names - constexpr const char *FLD_TYPE = "type"; - constexpr const char *FLD_CHALLENGE = "challenge"; - constexpr const char *FLD_SIG = "sig"; - constexpr const char *FLD_PUBKEY = "pubkey"; - constexpr const char *FLD_INPUT = "input"; - constexpr const char *FLD_INPUT_CONTAINER = "input_container"; - constexpr const char *FLD_INPUT_SIG = "input_sig"; - constexpr const char *FLD_MAX_LCL_SEQ = "max_lcl_seqno"; - constexpr const char *FLD_CONTENT = "content"; - constexpr const char *FLD_NONCE = "nonce"; - constexpr const char *FLD_LCL = "lcl"; - constexpr const char *FLD_LCL_SEQ = "lcl_seqno"; - constexpr const char *FLD_STATUS = "status"; - constexpr const char *FLD_REASON = "reason"; - - // Length of user random challenge bytes. - const size_t CHALLENGE_LEN = 16; + // std::vector overload to concatonate string. + std::vector &operator+=(std::vector &vec, std::string_view sv) + { + vec.insert(vec.end(), sv.begin(), sv.end()); + return vec; + } /** * Constructs user challenge message json and the challenge string required for @@ -45,16 +34,16 @@ namespace jsonschema::usrmsg * } * @param challengehex String reference to copy the generated hex challenge string into. */ - void create_user_challenge(std::string &msg, std::string &challengehex) + void create_user_challenge(std::vector &msg, std::string &challengehex) { // Use libsodium to generate the random challenge bytes. - unsigned char challenge_bytes[CHALLENGE_LEN]; - randombytes_buf(challenge_bytes, CHALLENGE_LEN); + unsigned char challenge_bytes[msg::usrmsg::CHALLENGE_LEN]; + randombytes_buf(challenge_bytes, msg::usrmsg::CHALLENGE_LEN); // We pass the hex challenge string separately to the caller even though // we also include it in the challenge msg as well. - util::bin2hex(challengehex, challenge_bytes, CHALLENGE_LEN); + util::bin2hex(challengehex, challenge_bytes, msg::usrmsg::CHALLENGE_LEN); // Construct the challenge msg json. // We do not use RapidJson here in favour of performance because this is a simple json message. @@ -63,15 +52,15 @@ namespace jsonschema::usrmsg // Only Hot Pocket version number is variable length. Therefore message size is roughly 90 bytes // so allocating 128bytes for heap padding. msg.reserve(128); - msg.append("{\"") - .append(FLD_TYPE) - .append(SEP_COLON) - .append(MSGTYPE_HANDSHAKE_CHALLENGE) - .append(SEP_COMMA) - .append(FLD_CHALLENGE) - .append(SEP_COLON) - .append(challengehex) - .append("\"}"); + msg += "{\""; + msg += msg::usrmsg::FLD_TYPE; + msg += SEP_COLON; + msg += msg::usrmsg::MSGTYPE_HANDSHAKE_CHALLENGE; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_CHALLENGE; + msg += SEP_COLON; + msg += challengehex; + msg += "\"}"; } /** @@ -84,22 +73,22 @@ namespace jsonschema::usrmsg * "lcl_seqno": * } */ - void create_status_response(std::string &msg) + void create_status_response(std::vector &msg) { msg.reserve(128); - msg.append("{\"") - .append(FLD_TYPE) - .append(SEP_COLON) - .append(MSGTYPE_STAT_RESPONSE) - .append(SEP_COMMA) - .append(FLD_LCL) - .append(SEP_COLON) - .append(cons::ctx.lcl) - .append(SEP_COMMA) - .append(FLD_LCL_SEQ) - .append(SEP_COLON_NOQUOTE) - .append(std::to_string(cons::ctx.led_seq_no)) - .append("}"); + msg += "{\""; + msg += msg::usrmsg::FLD_TYPE; + msg += SEP_COLON; + msg += msg::usrmsg::MSGTYPE_STAT_RESPONSE; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_LCL; + msg += SEP_COLON; + msg += cons::ctx.lcl; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_LCL_SEQ; + msg += SEP_COLON_NOQUOTE; + msg += std::to_string(cons::ctx.led_seq_no); + msg += "}"; } /** @@ -116,29 +105,29 @@ namespace jsonschema::usrmsg * @param reason Rejected reason. Empty if accepted. * @param input_sig Binary signature of the original input message which generated this result. */ - void create_contract_input_status(std::string &msg, std::string_view status, std::string_view reason, std::string_view input_sig) + void create_contract_input_status(std::vector &msg, std::string_view status, std::string_view reason, std::string_view input_sig) { std::string sighex; util::bin2hex(sighex, reinterpret_cast(input_sig.data()), input_sig.length()); msg.reserve(128); - msg.append("{\"") - .append(FLD_TYPE) - .append(SEP_COLON) - .append(MSGTYPE_CONTRACT_INPUT_STATUS) - .append(SEP_COMMA) - .append(FLD_STATUS) - .append(SEP_COLON) - .append(status) - .append(SEP_COMMA) - .append(FLD_REASON) - .append(SEP_COLON) - .append(reason) - .append(SEP_COMMA) - .append(FLD_INPUT_SIG) - .append(SEP_COLON) - .append(sighex) - .append("\"}"); + msg += "{\""; + msg += msg::usrmsg::FLD_TYPE; + msg += SEP_COLON; + msg += msg::usrmsg::MSGTYPE_CONTRACT_INPUT_STATUS; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_STATUS; + msg += SEP_COLON; + msg += status; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_REASON; + msg += SEP_COLON; + msg += reason; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_INPUT_SIG; + msg += SEP_COLON; + msg += sighex; + msg += "\"}"; } /** @@ -151,7 +140,7 @@ namespace jsonschema::usrmsg * } * @param content The contract binary output content to be put in the message. */ - void create_contract_read_response_container(std::string &msg, std::string_view content) + void create_contract_read_response_container(std::vector &msg, std::string_view content) { std::string contenthex; util::bin2hex( @@ -160,15 +149,15 @@ namespace jsonschema::usrmsg content.length()); msg.reserve(256); - msg.append("{\"") - .append(FLD_TYPE) - .append(SEP_COLON) - .append(MSGTYPE_CONTRACT_READ_RESPONSE) - .append(SEP_COMMA) - .append(FLD_CONTENT) - .append(SEP_COLON) - .append(contenthex) - .append("\"}"); + msg += "{\""; + msg += msg::usrmsg::FLD_TYPE; + msg += SEP_COLON; + msg += msg::usrmsg::MSGTYPE_CONTRACT_READ_RESPONSE; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_CONTENT; + msg += SEP_COLON; + msg += contenthex; + msg += "\"}"; } /** @@ -183,7 +172,7 @@ namespace jsonschema::usrmsg * } * @param content The contract binary output content to be put in the message. */ - void create_contract_output_container(std::string &msg, std::string_view content) + void create_contract_output_container(std::vector &msg, std::string_view content) { std::string contenthex; util::bin2hex( @@ -192,80 +181,98 @@ namespace jsonschema::usrmsg content.length()); msg.reserve(256); - msg.append("{\"") - .append(FLD_TYPE) - .append(SEP_COLON) - .append(MSGTYPE_CONTRACT_OUTPUT) - .append(SEP_COMMA) - .append(FLD_LCL) - .append(SEP_COLON) - .append(cons::ctx.lcl) - .append(SEP_COMMA) - .append(FLD_LCL_SEQ) - .append(SEP_COLON_NOQUOTE) - .append(std::to_string(cons::ctx.led_seq_no)) - .append(SEP_COMMA_NOQUOTE) - .append(FLD_CONTENT) - .append(SEP_COLON) - .append(contenthex) - .append("\"}"); + msg += "{\""; + msg += msg::usrmsg::FLD_TYPE; + msg += SEP_COLON; + msg += msg::usrmsg::MSGTYPE_CONTRACT_OUTPUT; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_LCL; + msg += SEP_COLON; + msg += cons::ctx.lcl; + msg += SEP_COMMA; + msg += msg::usrmsg::FLD_LCL_SEQ; + msg += SEP_COLON_NOQUOTE; + msg += std::to_string(cons::ctx.led_seq_no); + msg += SEP_COMMA_NOQUOTE; + msg += msg::usrmsg::FLD_CONTENT; + msg += SEP_COLON; + msg += contenthex; + msg += "\"}"; } /** - * Verifies the user challenge response with the original challenge issued to the user + * Verifies the user handshake response with the original challenge issued to the user * and the user public key contained in the response. * - * @param extracted_pubkeyhex The hex public key extracted from the response. + * @param extracted_pubkeyhex The hex public key extracted from the response. + * @param extracted_protocol The protocol code extracted from the response. * @param response The response bytes to verify. This will be parsed as json. * Accepted response format: * { - * "type": "challenge_resp", + * "type": "handshake_response", * "challenge": "", * "sig": "", - * "pubkey": "" + * "pubkey": "", + * "protocol": "" * } * @param original_challenge The original hex challenge string issued to the user. * @return 0 if challenge response is verified. -1 if challenge not met or an error occurs. */ - int verify_user_challenge_response(std::string &extracted_pubkeyhex, std::string_view response, std::string_view original_challenge) + int verify_user_handshake_response(std::string &extracted_pubkeyhex, std::string &extracted_protocol, + std::string_view response, std::string_view original_challenge) { rapidjson::Document d; if (parse_user_message(d, response) != 0) return -1; // Validate msg type. - if (d[FLD_TYPE] != MSGTYPE_HANDSHAKE_RESPONSE) + if (d[msg::usrmsg::FLD_TYPE] != msg::usrmsg::MSGTYPE_HANDSHAKE_RESPONSE) { - LOG_DBG << "User challenge response type invalid. 'challenge_response' expected."; + LOG_DBG << "User handshake response type invalid. 'handshake_response' expected."; return -1; } - // Compare the response challenge string with the original issued challenge. - if (!d.HasMember(FLD_CHALLENGE) || d[FLD_CHALLENGE] != original_challenge.data()) + // Compare the response handshake string with the original issued challenge. + if (!d.HasMember(msg::usrmsg::FLD_CHALLENGE) || d[msg::usrmsg::FLD_CHALLENGE] != original_challenge.data()) { - LOG_DBG << "User challenge response challenge invalid."; + LOG_DBG << "User handshake response 'challenge' invalid."; return -1; } // Check for the 'sig' field existence. - if (!d.HasMember(FLD_SIG) || !d[FLD_SIG].IsString()) + if (!d.HasMember(msg::usrmsg::FLD_SIG) || !d[msg::usrmsg::FLD_SIG].IsString()) { - LOG_DBG << "User challenge response signature invalid."; + LOG_DBG << "User handshake response 'challenge signature' invalid."; return -1; } // Check for the 'pubkey' field existence. - if (!d.HasMember(FLD_PUBKEY) || !d[FLD_PUBKEY].IsString()) + if (!d.HasMember(msg::usrmsg::FLD_PUBKEY) || !d[msg::usrmsg::FLD_PUBKEY].IsString()) { - LOG_DBG << "User challenge response public key invalid."; + LOG_DBG << "User handshake response 'public key' invalid."; + return -1; + } + + // Check for protocol field existence and valid value. + if (!d.HasMember(msg::usrmsg::FLD_PROTOCOL) || !d[msg::usrmsg::FLD_PROTOCOL].IsString()) + { + + LOG_DBG << "User handshake response 'protocol' invalid."; + return -1; + } + + std::string_view protocolsv = util::getsv(d[msg::usrmsg::FLD_PROTOCOL]); + if (protocolsv != "json" && protocolsv != "bson") + { + LOG_DBG << "User handshake response 'protocol' type invalid."; return -1; } // Verify the challenge signature. We do this last due to signature verification cost. - std::string_view pubkeysv = util::getsv(d[FLD_PUBKEY]); + std::string_view pubkeysv = util::getsv(d[msg::usrmsg::FLD_PUBKEY]); if (crypto::verify_hex( original_challenge, - util::getsv(d[FLD_SIG]), + util::getsv(d[msg::usrmsg::FLD_SIG]), pubkeysv) != 0) { LOG_DBG << "User challenge response signature verification failed."; @@ -273,10 +280,53 @@ namespace jsonschema::usrmsg } extracted_pubkeyhex = pubkeysv; + extracted_protocol = protocolsv; return 0; } + /** + * Parses a json message sent by a user. + * @param d RapidJson document to which the parsed json should be loaded. + * @param message The message to parse. + * Accepted message format: + * { + * 'type': '' + * ... + * } + * @return 0 on successful parsing. -1 for failure. + */ + int parse_user_message(rapidjson::Document &d, std::string_view message) + { + // We load response raw bytes into json document. + // Because we project the response message directly from the binary socket buffer in a zero-copy manner, the response + // string is not null terminated. 'kParseStopWhenDoneFlag' avoids rapidjson error in this case. + d.Parse(message.data()); + if (d.HasParseError()) + { + LOG_DBG << "User json message parsing failed."; + return -1; + } + + // Check existence of msg type field. + if (!d.HasMember(msg::usrmsg::FLD_TYPE) || !d[msg::usrmsg::FLD_TYPE].IsString()) + { + LOG_DBG << "User json message 'type' missing or invalid."; + return -1; + } + + return 0; + } + + /** + * Extracts the message 'type' value from the json document. + */ + int extract_type(std::string &extracted_type, const rapidjson::Document &d) + { + extracted_type = d[msg::usrmsg::FLD_TYPE].GetString(); + return 0; + } + /** * Extracts a contract read request message sent by user. * @@ -291,20 +341,20 @@ namespace jsonschema::usrmsg */ int extract_read_request(std::string &extracted_content, const rapidjson::Document &d) { - if (!d.HasMember(FLD_CONTENT)) + if (!d.HasMember(msg::usrmsg::FLD_CONTENT)) { LOG_DBG << "Read request required fields missing."; return -1; } - if (!d[FLD_CONTENT].IsString()) + if (!d[msg::usrmsg::FLD_CONTENT].IsString()) { LOG_DBG << "Read request invalid field values."; return -1; } - std::string_view contenthex(d[FLD_CONTENT].GetString(), d[FLD_CONTENT].GetStringLength()); - + std::string_view contenthex(d[msg::usrmsg::FLD_CONTENT].GetString(), d[msg::usrmsg::FLD_CONTENT].GetStringLength()); + std::string content; content.resize(contenthex.length() / 2); if (util::hex2bin( @@ -329,7 +379,7 @@ namespace jsonschema::usrmsg * Accepted signed input container format: * { * "type": "contract_input", - * "input_container": "", + * "input_container": "", * "sig": "" * } * @return 0 on successful extraction. -1 for failure. @@ -337,13 +387,13 @@ namespace jsonschema::usrmsg int extract_signed_input_container( std::string &extracted_input_container, std::string &extracted_sig, const rapidjson::Document &d) { - if (!d.HasMember(FLD_INPUT_CONTAINER) || !d.HasMember(FLD_SIG)) + if (!d.HasMember(msg::usrmsg::FLD_INPUT_CONTAINER) || !d.HasMember(msg::usrmsg::FLD_SIG)) { LOG_DBG << "User signed input required fields missing."; return -1; } - if (!d[FLD_INPUT_CONTAINER].IsString() || !d[FLD_SIG].IsString()) + if (!d[msg::usrmsg::FLD_INPUT_CONTAINER].IsString() || !d[msg::usrmsg::FLD_SIG].IsString()) { LOG_DBG << "User signed input invalid field values."; return -1; @@ -352,12 +402,15 @@ namespace jsonschema::usrmsg // We do not verify the signature of the content here since we need to let each node // (including self) to verify that individually after we broadcast the NUP proposal. - const std::string input_container(d[FLD_INPUT_CONTAINER].GetString(), d[FLD_INPUT_CONTAINER].GetStringLength()); + const std::string_view input_container_hex(d[msg::usrmsg::FLD_INPUT_CONTAINER].GetString(), d[msg::usrmsg::FLD_INPUT_CONTAINER].GetStringLength()); + std::string input_container; + input_container.resize(input_container_hex.size() / 2); + util::hex2bin(reinterpret_cast(input_container.data()), input_container.length(), input_container_hex); - const std::string_view sighex(d[FLD_SIG].GetString(), d[FLD_SIG].GetStringLength()); + const std::string_view sig_hex(d[msg::usrmsg::FLD_SIG].GetString(), d[msg::usrmsg::FLD_SIG].GetStringLength()); std::string sig; sig.resize(crypto_sign_ed25519_BYTES); - util::hex2bin(reinterpret_cast(sig.data()), sig.length(), sighex); + util::hex2bin(reinterpret_cast(sig.data()), sig.length(), sig_hex); extracted_input_container = std::move(input_container); extracted_sig = std::move(sig); @@ -387,19 +440,19 @@ namespace jsonschema::usrmsg return -1; } - if (!d.HasMember(FLD_NONCE) || !d.HasMember(FLD_INPUT) || !d.HasMember(FLD_MAX_LCL_SEQ)) + if (!d.HasMember(msg::usrmsg::FLD_INPUT) || !d.HasMember(msg::usrmsg::FLD_NONCE) || !d.HasMember(msg::usrmsg::FLD_MAX_LCL_SEQ)) { LOG_DBG << "User input container required fields missing."; return -1; } - if (!d[FLD_NONCE].IsString() || !d[FLD_INPUT].IsString() || !d[FLD_MAX_LCL_SEQ].IsUint64()) + if (!d[msg::usrmsg::FLD_INPUT].IsString() || !d[msg::usrmsg::FLD_NONCE].IsString() || !d[msg::usrmsg::FLD_MAX_LCL_SEQ].IsUint64()) { LOG_DBG << "User input container invalid field values."; return -1; } - const rapidjson::Value &inputval = d[FLD_INPUT]; + const rapidjson::Value &inputval = d[msg::usrmsg::FLD_INPUT]; std::string_view inputhex(inputval.GetString(), inputval.GetStringLength()); // Convert hex input to binary. @@ -413,43 +466,10 @@ namespace jsonschema::usrmsg return -1; } - nonce = d[FLD_NONCE].GetString(); - max_lcl_seqno = d[FLD_MAX_LCL_SEQ].GetUint64(); + nonce = d[msg::usrmsg::FLD_NONCE].GetString(); + max_lcl_seqno = d[msg::usrmsg::FLD_MAX_LCL_SEQ].GetUint64(); return 0; } - /** - * Parses a json message sent by a user. - * @param d RapidJson document to which the parsed json should be loaded. - * @param message The message to parse. - * Accepted message format: - * { - * 'type': '' - * ... - * } - * @return 0 on successful parsing. -1 for failure. - */ - int parse_user_message(rapidjson::Document &d, std::string_view message) - { - // We load response raw bytes into json document. - // Because we project the response message directly from the binary socket buffer in a zero-copy manner, the response - // string is not null terminated. 'kParseStopWhenDoneFlag' avoids rapidjson error in this case. - d.Parse(message.data()); - if (d.HasParseError()) - { - LOG_DBG << "User json message parsing failed."; - return -1; - } - - // Check existence of msg type field. - if (!d.HasMember(FLD_TYPE) || !d[FLD_TYPE].IsString()) - { - LOG_DBG << "User json message 'type' missing or invalid."; - return -1; - } - - return 0; - } - -} // namespace jsonschema::usrmsg \ No newline at end of file +} // namespace msg::usrmsg::json \ No newline at end of file diff --git a/src/msg/json/usrmsg_json.hpp b/src/msg/json/usrmsg_json.hpp new file mode 100644 index 00000000..b7b2d656 --- /dev/null +++ b/src/msg/json/usrmsg_json.hpp @@ -0,0 +1,37 @@ +#ifndef _HP_MSG_JSON_USRMSG_JSON_ +#define _HP_MSG_JSON_USRMSG_JSON_ + +#include "../../pchheader.hpp" + +namespace msg::usrmsg::json +{ + + void create_user_challenge(std::vector &msg, std::string &challengehex); + + void create_status_response(std::vector &msg); + + void create_contract_input_status(std::vector &msg, std::string_view status, std::string_view reason, + std::string_view input_sig); + + void create_contract_read_response_container(std::vector &msg, std::string_view content); + + void create_contract_output_container(std::vector &msg, std::string_view content); + + int verify_user_handshake_response(std::string &extracted_pubkeyhex, std::string &extracted_protocol, + std::string_view response, std::string_view original_challenge); + + int parse_user_message(rapidjson::Document &d, std::string_view message); + + int extract_type(std::string &extracted_type, const rapidjson::Document &d); + + int extract_read_request(std::string &extracted_content, const rapidjson::Document &d); + + int extract_signed_input_container(std::string &extracted_input_container, std::string &extracted_sig, + const rapidjson::Document &d); + + int extract_input_container(std::string &input, std::string &nonce, + uint64_t &max_lcl_seqno, std::string_view contentjson); + +} // namespace msg::usrmsg::json + +#endif \ No newline at end of file diff --git a/src/msg/usrmsg_common.hpp b/src/msg/usrmsg_common.hpp new file mode 100644 index 00000000..567896c6 --- /dev/null +++ b/src/msg/usrmsg_common.hpp @@ -0,0 +1,52 @@ +#ifndef _HP_MSG_USRMSG_COMMON_ +#define _HP_MSG_USRMSG_COMMON_ + +#include "../pchheader.hpp" + +namespace msg::usrmsg +{ + // Length of user random challenge bytes. + constexpr size_t CHALLENGE_LEN = 16; + + // Message field names + constexpr const char *FLD_TYPE = "type"; + constexpr const char *FLD_CHALLENGE = "challenge"; + constexpr const char *FLD_SIG = "sig"; + constexpr const char *FLD_PUBKEY = "pubkey"; + constexpr const char *FLD_PROTOCOL = "protocol"; + constexpr const char *FLD_INPUT = "input"; + constexpr const char *FLD_INPUT_CONTAINER = "input_container"; + constexpr const char *FLD_INPUT_SIG = "input_sig"; + constexpr const char *FLD_MAX_LCL_SEQ = "max_lcl_seqno"; + constexpr const char *FLD_CONTENT = "content"; + constexpr const char *FLD_NONCE = "nonce"; + constexpr const char *FLD_LCL = "lcl"; + constexpr const char *FLD_LCL_SEQ = "lcl_seqno"; + constexpr const char *FLD_STATUS = "status"; + constexpr const char *FLD_REASON = "reason"; + + // Message types + constexpr const char *MSGTYPE_HANDSHAKE_CHALLENGE = "handshake_challenge"; + constexpr const char *MSGTYPE_HANDSHAKE_RESPONSE = "handshake_response"; + constexpr const char *MSGTYPE_CONTRACT_READ_REQUEST = "contract_read_request"; + constexpr const char *MSGTYPE_CONTRACT_READ_RESPONSE = "contract_read_response"; + constexpr const char *MSGTYPE_CONTRACT_INPUT = "contract_input"; + constexpr const char *MSGTYPE_CONTRACT_INPUT_STATUS = "contract_input_status"; + constexpr const char *MSGTYPE_CONTRACT_OUTPUT = "contract_output"; + constexpr const char *MSGTYPE_STAT = "stat"; + constexpr const char *MSGTYPE_STAT_RESPONSE = "stat_response"; + constexpr const char *MSGTYPE_UNKNOWN = "unknown"; + + // Values + constexpr const char *STATUS_ACCEPTED = "accepted"; + constexpr const char *STATUS_REJECTED = "rejected"; + constexpr const char *REASON_BAD_MSG_FORMAT = "bad_msg_format"; + constexpr const char *REASON_INVALID_MSG_TYPE = "invalid_msg_type"; + constexpr const char *REASON_DUPLICATE_MSG = "dup_msg"; + constexpr const char *REASON_BAD_SIG = "bad_sig"; + constexpr const char *REASON_APPBILL_BALANCE_EXCEEDED = "appbill_balance_exceeded"; + constexpr const char *REASON_MAX_LEDGER_EXPIRED = "max_ledger_expired"; + +} // namespace msg::usrmsg + +#endif \ No newline at end of file diff --git a/src/msg/usrmsg_parser.cpp b/src/msg/usrmsg_parser.cpp new file mode 100644 index 00000000..9b11c837 --- /dev/null +++ b/src/msg/usrmsg_parser.cpp @@ -0,0 +1,90 @@ +#include "../pchheader.hpp" +#include "../util.hpp" +#include "json/usrmsg_json.hpp" +#include "bson/usrmsg_bson.hpp" +#include "usrmsg_parser.hpp" + +namespace jusrmsg = msg::usrmsg::json; +namespace busrmsg = msg::usrmsg::bson; + +namespace msg::usrmsg +{ + usrmsg_parser::usrmsg_parser(const util::PROTOCOL protocol) : protocol(protocol) + { + } + + void usrmsg_parser::create_status_response(std::vector &msg) const + { + if (protocol == util::PROTOCOL::JSON) + jusrmsg::create_status_response(msg); + else + busrmsg::create_status_response(msg); + } + + void usrmsg_parser::create_contract_input_status(std::vector &msg, std::string_view status, + std::string_view reason, std::string_view input_sig) const + { + if (protocol == util::PROTOCOL::JSON) + jusrmsg::create_contract_input_status(msg, status, reason, input_sig); + else + busrmsg::create_contract_input_status(msg, status, reason, input_sig); + } + + void usrmsg_parser::create_contract_read_response_container(std::vector &msg, std::string_view content) const + { + if (protocol == util::PROTOCOL::JSON) + jusrmsg::create_contract_read_response_container(msg, content); + else + busrmsg::create_contract_read_response_container(msg, content); + } + + void usrmsg_parser::create_contract_output_container(std::vector &msg, std::string_view content) const + { + if (protocol == util::PROTOCOL::JSON) + jusrmsg::create_contract_output_container(msg, content); + else + busrmsg::create_contract_output_container(msg, content); + } + + int usrmsg_parser::parse(std::string_view message) + { + if (protocol == util::PROTOCOL::JSON) + return jusrmsg::parse_user_message(jsonDoc, message); + else + return busrmsg::parse_user_message(bsonDoc, message); + } + + int usrmsg_parser::extract_type(std::string &extracted_type) const + { + if (protocol == util::PROTOCOL::JSON) + return jusrmsg::extract_type(extracted_type, jsonDoc); + else + return busrmsg::extract_type(extracted_type, bsonDoc); + } + + int usrmsg_parser::extract_read_request(std::string &extracted_content) const + { + if (protocol == util::PROTOCOL::JSON) + return jusrmsg::extract_read_request(extracted_content, jsonDoc); + else + return busrmsg::extract_read_request(extracted_content, bsonDoc); + } + + int usrmsg_parser::extract_signed_input_container(std::string &extracted_input_container, std::string &extracted_sig) const + { + if (protocol == util::PROTOCOL::JSON) + return jusrmsg::extract_signed_input_container(extracted_input_container, extracted_sig, jsonDoc); + else + return busrmsg::extract_signed_input_container(extracted_input_container, extracted_sig, bsonDoc); + } + + int usrmsg_parser::extract_input_container(std::string &input, std::string &nonce, + uint64_t &max_lcl_seqno, std::string_view encoded_content) const + { + if (protocol == util::PROTOCOL::JSON) + return jusrmsg::extract_input_container(input, nonce, max_lcl_seqno, encoded_content); + else + return busrmsg::extract_input_container(input, nonce, max_lcl_seqno, encoded_content); + } + +} // namespace msg::usrmsg \ No newline at end of file diff --git a/src/msg/usrmsg_parser.hpp b/src/msg/usrmsg_parser.hpp new file mode 100644 index 00000000..901a1d4a --- /dev/null +++ b/src/msg/usrmsg_parser.hpp @@ -0,0 +1,44 @@ +#ifndef _HP_MSG_USRMSG_PARSER_ +#define _HP_MSG_USRMSG_PARSER_ + +#include "../util.hpp" +#include "../pchheader.hpp" + +namespace msg::usrmsg +{ + // Forward declaration + class usrmsg_parser; + + class usrmsg_parser + { + const util::PROTOCOL protocol; + rapidjson::Document jsonDoc; + jsoncons::ojson bsonDoc; + + public: + usrmsg_parser(const util::PROTOCOL protocol); + + void create_status_response(std::vector &msg) const; + + void create_contract_input_status(std::vector &msg, std::string_view status, + std::string_view reason, std::string_view input_sig) const; + + void create_contract_read_response_container(std::vector &msg, std::string_view content) const; + + void create_contract_output_container(std::vector &msg, std::string_view content) const; + + int parse(std::string_view message); + + int extract_type(std::string &extracted_type) const; + + int extract_read_request(std::string &extracted_content) const; + + int extract_signed_input_container(std::string &extracted_input_container, std::string &extracted_sig) const; + + int extract_input_container(std::string &input, std::string &nonce, + uint64_t &max_lcl_seqno, std::string_view encoded_content) const; + }; + +} // namespace msg::usrmsg + +#endif \ No newline at end of file diff --git a/src/p2p/p2p.hpp b/src/p2p/p2p.hpp index 4fe09558..44950d48 100644 --- a/src/p2p/p2p.hpp +++ b/src/p2p/p2p.hpp @@ -28,7 +28,7 @@ namespace p2p struct nonunl_proposal { - std::unordered_map> user_messages; + std::unordered_map> user_inputs; }; struct history_request diff --git a/src/p2p/peer_session_handler.cpp b/src/p2p/peer_session_handler.cpp index e6d95666..667dba6e 100644 --- a/src/p2p/peer_session_handler.cpp +++ b/src/p2p/peer_session_handler.cpp @@ -3,10 +3,10 @@ #include "../crypto.hpp" #include "../util.hpp" #include "../hplog.hpp" -#include "../fbschema/p2pmsg_container_generated.h" -#include "../fbschema/p2pmsg_content_generated.h" -#include "../fbschema/p2pmsg_helpers.hpp" -#include "../fbschema/common_helpers.hpp" +#include "../msg/fbuf/p2pmsg_container_generated.h" +#include "../msg/fbuf/p2pmsg_content_generated.h" +#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/common_helpers.hpp" #include "../comm/comm_session.hpp" #include "../comm/comm_client.hpp" #include "p2p.hpp" @@ -15,7 +15,7 @@ #include "../state/state_sync.hpp" #include "../cons/cons.hpp" -namespace p2pmsg = fbschema::p2pmsg; +namespace p2pmsg = msg::fbuf::p2pmsg; namespace p2p { diff --git a/src/pchheader.hpp b/src/pchheader.hpp index 72be1a20..23d1c0be 100644 --- a/src/pchheader.hpp +++ b/src/pchheader.hpp @@ -30,6 +30,8 @@ #include #include #include +#include +#include #include #include #include diff --git a/src/sc.cpp b/src/sc.cpp index caf0ed18..d16bd135 100644 --- a/src/sc.cpp +++ b/src/sc.cpp @@ -1,9 +1,9 @@ #include "pchheader.hpp" #include "conf.hpp" #include "hplog.hpp" -#include "fbschema/common_helpers.hpp" -#include "fbschema/p2pmsg_container_generated.h" -#include "fbschema/p2pmsg_content_generated.h" +#include "msg/fbuf/common_helpers.hpp" +#include "msg/fbuf/p2pmsg_container_generated.h" +#include "msg/fbuf/p2pmsg_content_generated.h" #include "sc.hpp" #include "hpfs/hpfs.hpp" @@ -555,7 +555,7 @@ namespace sc uint8_t reserve = 0; //Get message container - const fbschema::p2pmsg::Container *container = fbschema::p2pmsg::GetContainer(input.data()); + const msg::fbuf::p2pmsg::Container *container = msg::fbuf::p2pmsg::GetContainer(input.data()); const flatbuffers::Vector *container_content = container->content(); uint16_t msg_length = container_content->size(); @@ -576,7 +576,7 @@ namespace sc memsegs[pre_header_index].iov_base = &pre_header; memsegs[pre_header_index].iov_len = 4; - std::string_view msg_pubkey = fbschema::flatbuff_bytes_to_sv(container->pubkey()); + std::string_view msg_pubkey = msg::fbuf::flatbuff_bytes_to_sv(container->pubkey()); memsegs[pubkey_index].iov_base = reinterpret_cast(const_cast(msg_pubkey.data())); memsegs[pubkey_index].iov_len = msg_pubkey.size(); diff --git a/src/state/state_serve.cpp b/src/state/state_serve.cpp index cda33ae2..c094c12b 100644 --- a/src/state/state_serve.cpp +++ b/src/state/state_serve.cpp @@ -3,15 +3,15 @@ #include "../hpfs/h32.hpp" #include "../util.hpp" #include "../p2p/p2p.hpp" -#include "../fbschema/p2pmsg_content_generated.h" -#include "../fbschema/p2pmsg_helpers.hpp" -#include "../fbschema/common_helpers.hpp" +#include "../msg/fbuf/p2pmsg_content_generated.h" +#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/common_helpers.hpp" #include "../cons/cons.hpp" #include "../hplog.hpp" #include "state_serve.hpp" #include "state_common.hpp" -namespace p2pmsg = fbschema::p2pmsg; +namespace p2pmsg = msg::fbuf::p2pmsg; /** * Helper functions for serving state requests from other peers. @@ -70,7 +70,7 @@ namespace state_serve if (is_shutting_down) break; - const fbschema::p2pmsg::Content *content = fbschema::p2pmsg::GetContent(request.data()); + const msg::fbuf::p2pmsg::Content *content = msg::fbuf::p2pmsg::GetContent(request.data()); const p2p::state_request sr = p2pmsg::create_state_request_from_msg(*content->message_as_State_Request_Message()); flatbuffers::FlatBufferBuilder fbuf(1024); @@ -132,7 +132,7 @@ namespace state_serve resp.hash = sr.expected_hash; resp.data = std::string_view(reinterpret_cast(block.data()), block.size()); - fbschema::p2pmsg::create_msg_from_block_response(fbuf, resp, cons::ctx.lcl); + msg::fbuf::p2pmsg::create_msg_from_block_response(fbuf, resp, cons::ctx.lcl); } else { @@ -147,7 +147,7 @@ namespace state_serve return -1; } - fbschema::p2pmsg::create_msg_from_filehashmap_response( + msg::fbuf::p2pmsg::create_msg_from_filehashmap_response( fbuf, sr.parent_path, block_hashes, file_length, sr.expected_hash, cons::ctx.lcl); } @@ -162,7 +162,7 @@ namespace state_serve return -1; } - fbschema::p2pmsg::create_msg_from_fsentry_response( + msg::fbuf::p2pmsg::create_msg_from_fsentry_response( fbuf, sr.parent_path, child_hash_nodes, sr.expected_hash, cons::ctx.lcl); } } diff --git a/src/state/state_serve.hpp b/src/state/state_serve.hpp index d4aa7d32..3657a0dd 100644 --- a/src/state/state_serve.hpp +++ b/src/state/state_serve.hpp @@ -4,7 +4,7 @@ #include "../hpfs/h32.hpp" #include "../hpfs/hpfs.hpp" #include "../p2p/p2p.hpp" -#include "../fbschema/p2pmsg_content_generated.h" +#include "../msg/fbuf/p2pmsg_content_generated.h" namespace state_serve { diff --git a/src/state/state_sync.cpp b/src/state/state_sync.cpp index f0cf3037..10bff227 100644 --- a/src/state/state_sync.cpp +++ b/src/state/state_sync.cpp @@ -1,6 +1,6 @@ -#include "../fbschema/p2pmsg_helpers.hpp" -#include "../fbschema/p2pmsg_content_generated.h" -#include "../fbschema/common_helpers.hpp" +#include "../msg/fbuf/p2pmsg_helpers.hpp" +#include "../msg/fbuf/p2pmsg_content_generated.h" +#include "../msg/fbuf/common_helpers.hpp" #include "../p2p/p2p.hpp" #include "../pchheader.hpp" #include "../cons/cons.hpp" @@ -159,12 +159,12 @@ namespace state_sync if (should_stop_request_loop(current_target)) return; - const fbschema::p2pmsg::Content *content = fbschema::p2pmsg::GetContent(response.data()); - const fbschema::p2pmsg::State_Response_Message *resp_msg = content->message_as_State_Response_Message(); + const msg::fbuf::p2pmsg::Content *content = msg::fbuf::p2pmsg::GetContent(response.data()); + const msg::fbuf::p2pmsg::State_Response_Message *resp_msg = content->message_as_State_Response_Message(); // Check whether we are actually waiting for this response. If not, ignore it. - std::string_view hash = fbschema::flatbuff_bytes_to_sv(resp_msg->hash()); - std::string_view vpath = fbschema::flatbuff_str_to_sv(resp_msg->path()); + 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()); const std::string key = std::string(vpath).append(hash); const auto pending_resp_itr = ctx.submitted_requests.find(key); @@ -178,13 +178,13 @@ namespace state_sync ctx.submitted_requests.erase(pending_resp_itr); // Process the message based on response type. - const fbschema::p2pmsg::State_Response msg_type = resp_msg->state_response_type(); + const msg::fbuf::p2pmsg::State_Response msg_type = resp_msg->state_response_type(); - if (msg_type == fbschema::p2pmsg::State_Response_Fs_Entry_Response) + if (msg_type == msg::fbuf::p2pmsg::State_Response_Fs_Entry_Response) handle_fs_entry_response(vpath, resp_msg->state_response_as_Fs_Entry_Response()); - else if (msg_type == fbschema::p2pmsg::State_Response_File_HashMap_Response) + else if (msg_type == msg::fbuf::p2pmsg::State_Response_File_HashMap_Response) handle_file_hashmap_response(vpath, resp_msg->state_response_as_File_HashMap_Response()); - else if (msg_type == fbschema::p2pmsg::State_Response_Block_Response) + else if (msg_type == msg::fbuf::p2pmsg::State_Response_Block_Response) handle_file_block_response(vpath, resp_msg->state_response_as_Block_Response()); // After handling each response, check whether we have reached target state. @@ -262,7 +262,7 @@ namespace state_sync sr.expected_hash = expected_hash; flatbuffers::FlatBufferBuilder fbuf(1024); - fbschema::p2pmsg::create_msg_from_state_request(fbuf, sr, cons::ctx.lcl); + msg::fbuf::p2pmsg::create_msg_from_state_request(fbuf, sr, cons::ctx.lcl); p2p::send_message_to_random_peer(fbuf); //todo: send to a node that hold the majority state to improve reliability of retrieving state. } @@ -286,14 +286,14 @@ namespace state_sync /** * Process dir children response. */ - int handle_fs_entry_response(std::string_view parent_vpath, const fbschema::p2pmsg::Fs_Entry_Response *fs_entry_resp) + int handle_fs_entry_response(std::string_view parent_vpath, const msg::fbuf::p2pmsg::Fs_Entry_Response *fs_entry_resp) { // Get the parent path of the fs entries we have received. LOG_DBG << "State sync: Processing fs entries response for " << parent_vpath; // Get fs entries we have received. std::unordered_map peer_fs_entry_map; - fbschema::p2pmsg::flatbuf_statefshashentry_to_statefshashentry(peer_fs_entry_map, fs_entry_resp->entries()); + msg::fbuf::p2pmsg::flatbuf_statefshashentry_to_statefshashentry(peer_fs_entry_map, fs_entry_resp->entries()); // Create physical directory on our side if not exist. std::string parent_physical_path = std::string(ctx.hpfs_mount_dir).append(parent_vpath); @@ -362,7 +362,7 @@ namespace state_sync /** * Process file block hash map response. */ - int handle_file_hashmap_response(std::string_view file_vpath, const fbschema::p2pmsg::File_HashMap_Response *file_resp) + int handle_file_hashmap_response(std::string_view file_vpath, const msg::fbuf::p2pmsg::File_HashMap_Response *file_resp) { // Get the file path of the block hashes we have received. LOG_DBG << "State sync: Processing file block hashes response for " << file_vpath; @@ -401,11 +401,11 @@ namespace state_sync /** * Process file block response. */ - int handle_file_block_response(std::string_view file_vpath, const fbschema::p2pmsg::Block_Response *block_msg) + int handle_file_block_response(std::string_view file_vpath, const msg::fbuf::p2pmsg::Block_Response *block_msg) { // Get the file path of the block data we have received. const uint32_t block_id = block_msg->block_id(); - std::string_view buf = fbschema::flatbuff_bytes_to_sv(block_msg->data()); + std::string_view buf = msg::fbuf::flatbuff_bytes_to_sv(block_msg->data()); LOG_DBG << "State sync: Writing block_id " << block_id << " (len:" << buf.length() diff --git a/src/state/state_sync.hpp b/src/state/state_sync.hpp index 6cd68f0e..d431906a 100644 --- a/src/state/state_sync.hpp +++ b/src/state/state_sync.hpp @@ -3,7 +3,7 @@ #include "../pchheader.hpp" #include "../p2p/p2p.hpp" -#include "../fbschema/p2pmsg_content_generated.h" +#include "../msg/fbuf/p2pmsg_content_generated.h" #include "../hpfs/h32.hpp" namespace state_sync @@ -72,11 +72,11 @@ namespace state_sync void submit_request(const backlog_item &request); - int handle_fs_entry_response(std::string_view parent_vpath, const fbschema::p2pmsg::Fs_Entry_Response *fs_entry_resp); + int handle_fs_entry_response(std::string_view parent_vpath, const msg::fbuf::p2pmsg::Fs_Entry_Response *fs_entry_resp); - int handle_file_hashmap_response(std::string_view file_vpath, const fbschema::p2pmsg::File_HashMap_Response *file_resp); + int handle_file_hashmap_response(std::string_view file_vpath, const msg::fbuf::p2pmsg::File_HashMap_Response *file_resp); - int handle_file_block_response(std::string_view file_vpath, const fbschema::p2pmsg::Block_Response *block_msg); + int handle_file_block_response(std::string_view file_vpath, const msg::fbuf::p2pmsg::Block_Response *block_msg); } // namespace state_sync diff --git a/src/usr/read_req.cpp b/src/usr/read_req.cpp index e52e31c9..7422d621 100644 --- a/src/usr/read_req.cpp +++ b/src/usr/read_req.cpp @@ -3,12 +3,10 @@ #include "../util.hpp" #include "../sc.hpp" #include "../conf.hpp" -#include "../jsonschema/usrmsg_helpers.hpp" +#include "../msg/usrmsg_parser.hpp" #include "usr.hpp" #include "read_req.hpp" -namespace jusrmsg = jsonschema::usrmsg; - /** * Helper functions for serving read requests from users. */ @@ -97,10 +95,12 @@ namespace read_req std::string outputtosend; outputtosend.swap(bufpair.output); - std::string msg; - jusrmsg::create_contract_read_response_container(msg, outputtosend); - const usr::connected_user &user = user_itr->second; + msg::usrmsg::usrmsg_parser parser(user.protocol); + + std::vector msg; + parser.create_contract_read_response_container(msg, outputtosend); + user.session.send(msg); dispatch_count++; } diff --git a/src/usr/user_input.hpp b/src/usr/user_input.hpp index d2e230ef..3200aba8 100644 --- a/src/usr/user_input.hpp +++ b/src/usr/user_input.hpp @@ -2,6 +2,7 @@ #define _HP_USR_USER_INPUT_ #include "../pchheader.hpp" +#include "../util.hpp" namespace usr { @@ -9,18 +10,19 @@ namespace usr /** * Represents a signed contract input message a network user has submitted. */ -struct user_submitted_message +struct user_input { - const std::string content; + const std::string input_container; const std::string sig; + const util::PROTOCOL protocol; // The encoding protocol used for the input container. - user_submitted_message(const std::string content, const std::string sig) - : content(std::move(content)), sig(std::move(sig)) + user_input(const std::string input_container, const std::string sig, const util::PROTOCOL protocol) + : input_container(std::move(input_container)), sig(std::move(sig)), protocol(protocol) { } - user_submitted_message(std::string_view content, std::string_view sig) - : content(content), sig(sig) + user_input(std::string_view input_container, std::string_view sig, const util::PROTOCOL protocol) + : input_container(input_container), sig(sig), protocol(protocol) { } }; diff --git a/src/usr/user_session_handler.cpp b/src/usr/user_session_handler.cpp index b6e0d6f0..9007af42 100644 --- a/src/usr/user_session_handler.cpp +++ b/src/usr/user_session_handler.cpp @@ -1,11 +1,11 @@ #include "../pchheader.hpp" #include "../hplog.hpp" -#include "../jsonschema/usrmsg_helpers.hpp" +#include "../msg/json/usrmsg_json.hpp" #include "../bill/corebill.h" #include "usr.hpp" #include "user_session_handler.hpp" -namespace jusrmsg = jsonschema::usrmsg; +namespace jusrmsg = msg::usrmsg::json; namespace usr { @@ -25,9 +25,9 @@ int user_session_handler::on_connect(comm::comm_session &session) const // As soon as a user connects, we issue them a challenge message. We remember the // challenge we issued and later verify the user's response with it. - std::string msgstr; - jusrmsg::create_user_challenge(msgstr, session.issued_challenge); - session.send(msgstr); + std::vector msg; + jusrmsg::create_user_challenge(msg, session.issued_challenge); + session.send(msg); // Set the challenge-issued value to true. session.challenge_status = comm::CHALLENGE_ISSUED; diff --git a/src/usr/usr.cpp b/src/usr/usr.cpp index d930555d..3d5a28ea 100644 --- a/src/usr/usr.cpp +++ b/src/usr/usr.cpp @@ -1,5 +1,7 @@ #include "../pchheader.hpp" -#include "../jsonschema/usrmsg_helpers.hpp" +#include "../msg/json/usrmsg_json.hpp" +#include "../msg/usrmsg_parser.hpp" +#include "../msg/usrmsg_common.hpp" #include "../comm/comm_server.hpp" #include "../comm/comm_session.hpp" #include "../util.hpp" @@ -10,8 +12,6 @@ #include "user_session_handler.hpp" #include "user_input.hpp" -namespace jusrmsg = jsonschema::usrmsg; - namespace usr { @@ -78,8 +78,10 @@ namespace usr } std::string userpubkeyhex; + std::string protocol_code; std::string_view original_challenge = session.issued_challenge; - if (jusrmsg::verify_user_challenge_response(userpubkeyhex, message, original_challenge) == 0) + + if (msg::usrmsg::json::verify_user_handshake_response(userpubkeyhex, protocol_code, message, original_challenge) == 0) { // Challenge signature verification successful. @@ -98,8 +100,10 @@ namespace usr // All good. Unique public key. // Promote the connection from pending-challenges to authenticated users. + const util::PROTOCOL user_protocol = (protocol_code == "json" ? util::PROTOCOL::JSON : util::PROTOCOL::BSON); + session.challenge_status = comm::CHALLENGE_VERIFIED; // Set as challenge verified - add_user(session, userpubkey); // Add the user to the global authed user list + add_user(session, userpubkey, user_protocol); // Add the user to the global authed user list session.issued_challenge.clear(); // Remove the stored challenge LOG_DBG << "User connection " << session.uniqueid << " authenticated. Public key " @@ -127,17 +131,17 @@ namespace usr */ int handle_user_message(connected_user &user, std::string_view message) { - rapidjson::Document d; - const char *msg_type = jusrmsg::MSGTYPE_UNKNOWN; + msg::usrmsg::usrmsg_parser parser(user.protocol); - if (jusrmsg::parse_user_message(d, message) == 0) + if (parser.parse(message) == 0) { - const char *msg_type = d[jusrmsg::FLD_TYPE].GetString(); + std::string msg_type; + parser.extract_type(msg_type); - if (d[jusrmsg::FLD_TYPE] == jusrmsg::MSGTYPE_CONTRACT_READ_REQUEST) + if (msg_type == msg::usrmsg::MSGTYPE_CONTRACT_READ_REQUEST) { std::string content; - if (jusrmsg::extract_read_request(content, d) == 0) + if (parser.extract_read_request(content) == 0) { std::lock_guard lock(ctx.users_mutex); @@ -147,50 +151,51 @@ namespace usr } else { - send_input_status(user.session, jusrmsg::STATUS_REJECTED, jusrmsg::REASON_BAD_MSG_FORMAT, ""); + send_input_status(parser, user.session, msg::usrmsg::STATUS_REJECTED, msg::usrmsg::REASON_BAD_MSG_FORMAT, ""); return -1; } } - else if (d[jusrmsg::FLD_TYPE] == jusrmsg::MSGTYPE_CONTRACT_INPUT) + else if (msg_type == msg::usrmsg::MSGTYPE_CONTRACT_INPUT) { // Message is a contract input message. - std::string input_container_json; + std::string input_container; std::string sig; - if (jusrmsg::extract_signed_input_container(input_container_json, sig, d) == 0) + if (parser.extract_signed_input_container(input_container, sig) == 0) { std::lock_guard lock(ctx.users_mutex); //Add to the submitted input list. - user.submitted_inputs.push_back(user_submitted_message( - std::move(input_container_json), - std::move(sig))); + user.submitted_inputs.push_back(user_input( + std::move(input_container), + std::move(sig), + user.protocol)); return 0; } else { - send_input_status(user.session, jusrmsg::STATUS_REJECTED, jusrmsg::REASON_BAD_SIG, sig); + send_input_status(parser, user.session, msg::usrmsg::STATUS_REJECTED, msg::usrmsg::REASON_BAD_SIG, sig); return -1; } } - else if (d[jusrmsg::FLD_TYPE] == jusrmsg::MSGTYPE_STAT) + else if (msg_type == msg::usrmsg::MSGTYPE_STAT) { - std::string msg; - jusrmsg::create_status_response(msg); + std::vector msg; + parser.create_status_response(msg); user.session.send(msg); return 0; } else { LOG_DBG << "Invalid user message type: " << msg_type; - send_input_status(user.session, jusrmsg::STATUS_REJECTED, jusrmsg::REASON_INVALID_MSG_TYPE, ""); + send_input_status(parser, user.session, msg::usrmsg::STATUS_REJECTED, msg::usrmsg::REASON_INVALID_MSG_TYPE, ""); return -1; } } else { // Bad message. - send_input_status(user.session, jusrmsg::STATUS_REJECTED, jusrmsg::REASON_BAD_MSG_FORMAT, ""); + send_input_status(parser, user.session, msg::usrmsg::STATUS_REJECTED, msg::usrmsg::REASON_BAD_MSG_FORMAT, ""); return -1; } } @@ -198,10 +203,11 @@ namespace usr /** * Send the specified contract input status result via the provided session. */ - void send_input_status(const comm::comm_session &session, std::string_view status, std::string_view reason, std::string_view input_sig) + void send_input_status(const msg::usrmsg::usrmsg_parser &parser, const comm::comm_session &session, + std::string_view status, std::string_view reason, std::string_view input_sig) { - std::string msg; - jusrmsg::create_contract_input_status(msg, status, reason, input_sig); + std::vector msg; + parser.create_contract_input_status(msg, status, reason, input_sig); session.send(msg); } @@ -211,9 +217,10 @@ namespace usr * * @param session User socket session. * @param pubkey User's binary public key. + * @param protocol Messaging protocol used by user. * @return 0 on successful additions. -1 on failure. */ - int add_user(const comm::comm_session &session, const std::string &pubkey) + int add_user(const comm::comm_session &session, const std::string &pubkey, const util::PROTOCOL protocol) { const std::string &sessionid = session.uniqueid; if (ctx.users.count(sessionid) == 1) @@ -224,7 +231,7 @@ namespace usr { std::lock_guard lock(ctx.users_mutex); - ctx.users.emplace(sessionid, usr::connected_user(session, pubkey)); + ctx.users.emplace(sessionid, usr::connected_user(session, pubkey, protocol)); } // Populate sessionid map so we can lookup by user pubkey. diff --git a/src/usr/usr.hpp b/src/usr/usr.hpp index 2cce892f..c1286204 100644 --- a/src/usr/usr.hpp +++ b/src/usr/usr.hpp @@ -5,6 +5,7 @@ #include "../util.hpp" #include "../comm/comm_server.hpp" #include "../comm/comm_session.hpp" +#include "../msg/usrmsg_parser.hpp" #include "user_session_handler.hpp" #include "user_input.hpp" @@ -13,7 +14,6 @@ */ namespace usr { - /** * Holds information about an authenticated (challenge-verified) user * connected to the HotPocket node. @@ -24,7 +24,7 @@ namespace usr const std::string pubkey; // Holds the unprocessed user inputs collected from websocket. - std::list submitted_inputs; + std::list submitted_inputs; // Holds the unprocessed read requests collected from websocket. std::list read_requests; @@ -33,12 +33,15 @@ namespace usr // We don't need to own the session object since the lifetime of user and session are coupled. const comm::comm_session &session; + // The messaging protocol used by this user. + const util::PROTOCOL protocol; + /** * @param session The web socket session the user is connected to. * @param pubkey The public key of the user in binary format. */ - connected_user(const comm::comm_session &session, std::string_view pubkey) - : session(session), pubkey(pubkey) + connected_user(const comm::comm_session &session, std::string_view pubkey, util::PROTOCOL protocol) + : session(session), pubkey(pubkey), protocol(protocol) { } }; @@ -72,9 +75,10 @@ namespace usr int handle_user_message(connected_user &user, std::string_view message); - void send_input_status(const comm::comm_session &session, std::string_view status, std::string_view reason, std::string_view input_sig); + void send_input_status(const msg::usrmsg::usrmsg_parser &parser, const comm::comm_session &session, + std::string_view status, std::string_view reason, std::string_view input_sig); - int add_user(const comm::comm_session &session, const std::string &pubkey); + int add_user(const comm::comm_session &session, const std::string &pubkey, const util::PROTOCOL protocol); int remove_user(const std::string &sessionid); diff --git a/src/util.hpp b/src/util.hpp index 032654cd..0cd1120c 100644 --- a/src/util.hpp +++ b/src/util.hpp @@ -65,6 +65,15 @@ namespace util bool exists(const std::string &key); }; + /** + * The messaging protocol used in a web socket channel. + */ + enum PROTOCOL + { + JSON = 0, + BSON = 1 + }; + int bin2hex(std::string &encoded_string, const unsigned char *bin, const size_t bin_len); int hex2bin(unsigned char *decoded, const size_t decoded_len, std::string_view hex_str); diff --git a/test/vm-cluster/setup-vm.sh b/test/vm-cluster/setup-vm.sh index bb3bb1d2..d4670a8f 100755 --- a/test/vm-cluster/setup-vm.sh +++ b/test/vm-cluster/setup-vm.sh @@ -8,6 +8,8 @@ hpcore=$5 echo $nodeid. $vmip +strip $hpcore/build/hpcore + if [ $mode = "new" ]; then sshpass -f vmpass.txt scp $hpcore/build/hpcore \