onion-wownero-blockchain-ex.../main.cpp

342 lines
9.7 KiB
C++
Raw Normal View History

2016-12-19 01:47:19 +00:00
#define CROW_ENABLE_SSL
2016-04-06 06:53:37 +00:00
2016-09-06 10:34:07 +00:00
#include "ext/crow/crow.h"
2016-04-13 08:46:08 +00:00
#include "src/CmdLineOptions.h"
2016-04-06 06:53:37 +00:00
#include "src/MicroCore.h"
2016-04-08 06:54:04 +00:00
#include "src/page.h"
2016-09-06 10:34:07 +00:00
2016-04-24 01:11:08 +00:00
#include "ext/member_checker.h"
2016-04-06 06:53:37 +00:00
2016-04-07 07:01:49 +00:00
#include <fstream>
2016-04-06 06:53:37 +00:00
using boost::filesystem::path;
using namespace std;
2016-04-13 08:46:08 +00:00
int main(int ac, const char* av[]) {
// get command line options
xmreg::CmdLineOptions opts {ac, av};
auto help_opt = opts.get_option<bool>("help");
auto testnet_opt = opts.get_option<bool>("testnet");
auto enable_pusher_opt = opts.get_option<bool>("enable-pusher");
2016-04-13 08:46:08 +00:00
// if help was chosen, display help text and finish
if (*help_opt)
{
2016-05-07 10:37:26 +00:00
return EXIT_SUCCESS;
2016-04-13 08:46:08 +00:00
}
bool testnet {*testnet_opt};
bool enable_pusher {*enable_pusher_opt};
2016-09-06 11:19:10 +00:00
2016-05-07 10:33:56 +00:00
auto port_opt = opts.get_option<string>("port");
auto bc_path_opt = opts.get_option<string>("bc-path");
auto custom_db_path_opt = opts.get_option<string>("custom-db-path");
auto deamon_url_opt = opts.get_option<string>("deamon-url");
2016-12-19 01:47:19 +00:00
auto ssl_crt_file_opt = opts.get_option<string>("ssl-crt-file");
auto ssl_key_file_opt = opts.get_option<string>("ssl-key-file");
2016-04-13 08:46:08 +00:00
// set monero log output level
uint32_t log_level = 0;
mlog_configure("", true);
2016-04-14 07:58:01 +00:00
//cast port number in string to uint16
2016-04-13 08:46:08 +00:00
uint16_t app_port = boost::lexical_cast<uint16_t>(*port_opt);
2016-12-19 01:47:19 +00:00
bool use_ssl {false};
string ssl_crt_file;
string ssl_key_file;
// check if ssl enabled and files exist
if (ssl_crt_file_opt and ssl_key_file_opt)
{
if (!boost::filesystem::exists(boost::filesystem::path(*ssl_crt_file_opt)))
{
cerr << "ssl_crt_file path: " << *ssl_crt_file_opt
<< "does not exist!" << endl;
return EXIT_FAILURE;
}
if (!boost::filesystem::exists(boost::filesystem::path(*ssl_key_file_opt)))
{
cerr << "ssl_key_file path: " << *ssl_key_file_opt
<< "does not exist!" << endl;
return EXIT_FAILURE;
}
ssl_crt_file = *ssl_crt_file_opt;
ssl_key_file = *ssl_key_file_opt;
use_ssl = true;
}
2016-04-16 09:58:21 +00:00
// get blockchain path
path blockchain_path;
2016-04-06 06:53:37 +00:00
2016-09-06 11:19:10 +00:00
if (!xmreg::get_blockchain_path(bc_path_opt, blockchain_path, testnet))
2016-04-16 09:58:21 +00:00
{
cerr << "Error getting blockchain path." << endl;
2016-05-07 10:37:26 +00:00
return EXIT_FAILURE;
2016-04-16 09:58:21 +00:00
}
2016-04-06 06:53:37 +00:00
2016-09-06 11:19:10 +00:00
cout << blockchain_path << endl;
2016-04-06 09:15:09 +00:00
// create instance of our MicroCore
2016-04-16 09:58:21 +00:00
// and make pointer to the Blockchain
2016-04-06 09:15:09 +00:00
xmreg::MicroCore mcore;
2016-04-07 05:41:15 +00:00
cryptonote::Blockchain* core_storage;
2016-04-06 09:15:09 +00:00
2016-04-16 09:58:21 +00:00
// initialize mcore and core_storage
2016-04-07 05:41:15 +00:00
if (!xmreg::init_blockchain(blockchain_path.string(),
mcore, core_storage))
2016-04-06 09:15:09 +00:00
{
cerr << "Error accessing blockchain." << endl;
2016-05-07 10:37:26 +00:00
return EXIT_FAILURE;
2016-04-06 09:15:09 +00:00
}
2016-05-22 04:25:39 +00:00
// check if we have path to lmdb2 (i.e., custom db)
// and if it exists
string custom_db_path_str;
if (custom_db_path_opt)
{
if (boost::filesystem::exists(boost::filesystem::path(*custom_db_path_opt)))
{
custom_db_path_str = *custom_db_path_opt;
}
else
{
cerr << "Custom db path: " << *custom_db_path_opt
<< "does not exist" << endl;
return EXIT_FAILURE;
}
}
else
{
// if not given assume it is located in ~./bitmonero/lmdb2 folder
2016-10-24 05:52:44 +00:00
// or ~./bitmonero/testnet/lmdb2 for testnet network
2016-05-22 04:25:39 +00:00
custom_db_path_str = blockchain_path.parent_path().string()
+ string("/lmdb2");
}
custom_db_path_str = xmreg::remove_trailing_path_separator(custom_db_path_str);
2016-09-06 11:19:10 +00:00
string deamon_url {*deamon_url_opt};
if (testnet && deamon_url == "http:://127.0.0.1:18081")
2016-09-06 11:19:10 +00:00
deamon_url = "http:://127.0.0.1:28081";
2016-04-14 07:58:01 +00:00
// create instance of page class which
2016-04-16 09:58:21 +00:00
// contains logic for the website
xmreg::page xmrblocks(&mcore,
core_storage,
2016-09-06 11:19:10 +00:00
deamon_url,
custom_db_path_str,
testnet,
enable_pusher);
2016-04-07 06:32:28 +00:00
2016-04-14 07:58:01 +00:00
// crow instance
2016-04-06 06:53:37 +00:00
crow::SimpleApp app;
CROW_ROUTE(app, "/")
2016-08-20 09:16:18 +00:00
([&](const crow::request& req) {
2016-08-20 10:37:37 +00:00
return crow::response(xmrblocks.index2());
2016-04-12 03:31:26 +00:00
});
2016-04-15 02:59:41 +00:00
CROW_ROUTE(app, "/page/<uint>")
([&](size_t page_no) {
2016-05-01 02:13:44 +00:00
return xmrblocks.index2(page_no);
2016-04-15 02:59:41 +00:00
});
2016-04-15 23:07:47 +00:00
CROW_ROUTE(app, "/block/<uint>")
([&](const crow::request& req, size_t block_height) {
return crow::response(xmrblocks.show_block(block_height));
2016-04-15 23:07:47 +00:00
});
CROW_ROUTE(app, "/block/<string>")
([&](const crow::request& req, string block_hash) {
return crow::response(xmrblocks.show_block(block_hash));
});
2016-08-20 09:16:18 +00:00
2016-04-18 05:57:38 +00:00
CROW_ROUTE(app, "/tx/<string>")
2016-08-20 09:20:12 +00:00
([&](const crow::request& req, string tx_hash) {
return crow::response(xmrblocks.show_tx(tx_hash));
2016-04-18 05:57:38 +00:00
});
2016-04-15 23:07:47 +00:00
CROW_ROUTE(app, "/tx/<string>/<uint>")
([&](string tx_hash, uint with_ring_signatures) {
return xmrblocks.show_tx(tx_hash, with_ring_signatures);
});
CROW_ROUTE(app, "/myoutputs").methods("POST"_method)
2016-05-09 05:48:03 +00:00
([&](const crow::request& req) {
2016-05-09 05:53:33 +00:00
map<std::string, std::string> post_body = xmreg::parse_crow_post_data(req.body);
if (post_body.count("xmr_address") == 0
|| post_body.count("viewkey") == 0
|| post_body.count("tx_hash") == 0)
{
2017-01-18 12:15:15 +00:00
return string("xmr address, viewkey or tx hash not provided");
}
string tx_hash = post_body["tx_hash"];
string xmr_address = post_body["xmr_address"];
string viewkey = post_body["viewkey"];
2016-05-09 05:53:33 +00:00
2016-05-09 03:44:36 +00:00
return xmrblocks.show_my_outputs(tx_hash, xmr_address, viewkey);
});
2016-04-24 03:42:49 +00:00
CROW_ROUTE(app, "/prove").methods("POST"_method)
([&](const crow::request& req) {
2016-09-18 02:12:40 +00:00
map<std::string, std::string> post_body = xmreg::parse_crow_post_data(req.body);
2016-09-18 02:12:40 +00:00
2017-01-18 12:15:15 +00:00
if (post_body.count("xmraddress") == 0
|| post_body.count("txprvkey") == 0
2017-01-18 12:15:15 +00:00
|| post_body.count("txhash") == 0)
{
2017-01-18 12:15:15 +00:00
return string("xmr address, tx private key or tx hash not provided");
}
2016-09-18 02:12:40 +00:00
2017-01-18 12:15:15 +00:00
string tx_hash = post_body["txhash"];;
string tx_prv_key = post_body["txprvkey"];;
2017-01-18 12:15:15 +00:00
string xmr_address = post_body["xmraddress"];;
return xmrblocks.show_prove(tx_hash, xmr_address, tx_prv_key);
2016-09-18 02:12:40 +00:00
});
CROW_ROUTE(app, "/rawtx")
([&](const crow::request& req) {
return xmrblocks.show_rawtx();
});
2016-09-18 02:12:40 +00:00
2016-10-11 05:38:27 +00:00
CROW_ROUTE(app, "/checkandpush").methods("POST"_method)
2016-09-27 06:45:34 +00:00
([&](const crow::request& req) {
2016-09-27 23:44:39 +00:00
map<std::string, std::string> post_body = xmreg::parse_crow_post_data(req.body);
if (post_body.count("rawtxdata") == 0 || post_body.count("action") == 0)
{
return string("Raw tx data or action not provided");
}
string raw_tx_data = post_body["rawtxdata"];
string action = post_body["action"];
2016-10-11 05:38:27 +00:00
if (action == "check")
return xmrblocks.show_checkrawtx(raw_tx_data, action);
else if (action == "push")
return xmrblocks.show_pushrawtx(raw_tx_data, action);
2016-10-11 04:01:46 +00:00
});
2016-10-24 04:12:40 +00:00
CROW_ROUTE(app, "/rawkeyimgs")
([&](const crow::request& req) {
return xmrblocks.show_rawkeyimgs();
});
CROW_ROUTE(app, "/checkrawkeyimgs").methods("POST"_method)
([&](const crow::request& req) {
map<std::string, std::string> post_body = xmreg::parse_crow_post_data(req.body);
if (post_body.count("rawkeyimgsdata") == 0)
{
return string("Raw key images data not given");
}
if (post_body.count("viewkey") == 0)
{
return string("Viewkey not provided. Cant decrypt key image file without it");
}
string raw_data = post_body["rawkeyimgsdata"];
string viewkey = post_body["viewkey"];
return xmrblocks.show_checkrawkeyimgs(raw_data, viewkey);
});
2016-10-11 04:01:46 +00:00
CROW_ROUTE(app, "/rawoutputkeys")
([&](const crow::request& req) {
return xmrblocks.show_rawoutputkeys();
});
CROW_ROUTE(app, "/checkrawoutputkeys").methods("POST"_method)
([&](const crow::request& req) {
map<std::string, std::string> post_body = xmreg::parse_crow_post_data(req.body);
if (post_body.count("rawoutputkeysdata") == 0)
{
return string("Raw output keys data not given");
}
if (post_body.count("viewkey") == 0)
{
return string("Viewkey not provided. Cant decrypt key image file without it");
}
string raw_data = post_body["rawoutputkeysdata"];
string viewkey = post_body["viewkey"];
return xmrblocks.show_checkcheckrawoutput(raw_data, viewkey);
});
2016-04-24 03:42:49 +00:00
CROW_ROUTE(app, "/search").methods("GET"_method)
2016-05-06 01:00:22 +00:00
([&](const crow::request& req) {
2016-04-24 03:42:49 +00:00
return xmrblocks.search(string(req.url_params.get("value")));
});
2017-01-20 01:36:35 +00:00
CROW_ROUTE(app, "/mempool")
([&](const crow::request& req) {
2017-01-20 01:43:09 +00:00
return xmrblocks.mempool(true);
2017-01-20 01:36:35 +00:00
});
2016-11-23 23:13:34 +00:00
CROW_ROUTE(app, "/robots.txt")
([&]() {
string text = "User-agent: *\n"
"Disallow: ";
return text;
});
2016-08-20 08:59:24 +00:00
CROW_ROUTE(app, "/autorefresh")
([&]() {
2016-04-15 02:59:41 +00:00
uint64_t page_no {0};
bool refresh_page {true};
2016-05-01 03:31:57 +00:00
return xmrblocks.index2(page_no, refresh_page);
});
2016-04-12 03:31:26 +00:00
2016-04-14 07:58:01 +00:00
// run the crow http server
2016-12-19 01:47:19 +00:00
if (use_ssl)
{
cout << "Staring in ssl mode" << endl;
app.port(app_port).ssl_file(ssl_crt_file, ssl_key_file).multithreaded().run();
}
else
{
cout << "Staring in non-ssl mode" << endl;
app.port(app_port).multithreaded().run();
}
2016-04-06 06:53:37 +00:00
2016-05-07 10:37:26 +00:00
return EXIT_SUCCESS;
2016-04-15 03:10:55 +00:00
}