From d35893d926c74893d7c85d1b87b24ffa55744649 Mon Sep 17 00:00:00 2001 From: fireice-uk Date: Thu, 9 Nov 2017 22:43:08 +0000 Subject: Multi-pool final version (#90) * Multi-pool first draft * Fix wspace from new IDE * Better TLS error message * Fix TLS bug * Don't put dev pool on stats + pool change-back * bug fixes * Error message work * fix win build * add per-pool nicehash setting * Fix bugs * rm debug msg * Multipool guided setup * Support TLS and Nicehash in config * prelim jconf changes * final multipool changes * increase default retry_time to 30, fix mac erro * rm debug dev pool settings * Fix another source of connect runaway --- xmrstak/backend/cpu/jconf.hpp | 3 - xmrstak/backend/globalStates.hpp | 5 +- xmrstak/cli/cli-miner.cpp | 220 +++++++++++++++----- xmrstak/config.tpl | 35 ++-- xmrstak/jconf.cpp | 163 ++++++++++----- xmrstak/jconf.hpp | 31 +-- xmrstak/misc/executor.cpp | 420 +++++++++++++++++++++++---------------- xmrstak/misc/executor.hpp | 43 ++-- xmrstak/net/jpsock.cpp | 31 ++- xmrstak/net/jpsock.hpp | 42 +++- xmrstak/net/msgstruct.hpp | 50 ++++- xmrstak/net/socket.cpp | 67 ++++--- 12 files changed, 719 insertions(+), 391 deletions(-) (limited to 'xmrstak') diff --git a/xmrstak/backend/cpu/jconf.hpp b/xmrstak/backend/cpu/jconf.hpp index 3c7da49..f843ed4 100644 --- a/xmrstak/backend/cpu/jconf.hpp +++ b/xmrstak/backend/cpu/jconf.hpp @@ -31,9 +31,6 @@ public: bool GetThreadConfig(size_t id, thd_cfg &cfg); bool NeedsAutoconf(); - - - private: jconf(); static jconf* oInst; diff --git a/xmrstak/backend/globalStates.hpp b/xmrstak/backend/globalStates.hpp index 1c28d5c..9fdda2a 100644 --- a/xmrstak/backend/globalStates.hpp +++ b/xmrstak/backend/globalStates.hpp @@ -6,6 +6,7 @@ #include +constexpr static size_t invalid_pool_id = (-1); namespace xmrstak { @@ -15,7 +16,7 @@ struct pool_data uint32_t iSavedNonce; size_t pool_id; - pool_data() : iSavedNonce(0), pool_id(0) + pool_data() : iSavedNonce(0), pool_id(invalid_pool_id) { } }; @@ -46,7 +47,7 @@ struct globalStates std::atomic iConsumeCnt; std::atomic iGlobalNonce; uint64_t iThreadCount; - size_t pool_id; + size_t pool_id = invalid_pool_id; private: globalStates() : iThreadCount(0) diff --git a/xmrstak/cli/cli-miner.cpp b/xmrstak/cli/cli-miner.cpp index 81639ef..5c16c1b 100644 --- a/xmrstak/cli/cli-miner.cpp +++ b/xmrstak/cli/cli-miner.cpp @@ -49,7 +49,6 @@ #include #endif - #ifdef _WIN32 # define strcasecmp _stricmp #endif // _WIN32 @@ -90,6 +89,170 @@ void help() cout<<"Brought to by fireice_uk and psychocrypt under GPLv3."<> tmp; + std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower); + } + while(tmp != "y" && tmp != "n" && tmp != "yes" && tmp != "no"); + + return tmp == "y" || tmp == "yes"; +} + +inline const char* bool_to_str(bool v) +{ + return v ? "true" : "false"; +} + +std::string get_multipool_entry(bool& final) +{ + std::cout<> pool; + + std::string userName; + std::cout<<"- Username (wallet address or pool login):"<> userName; + + std::string passwd; + std::cin.clear(); std::cin.ignore(INT_MAX,'\n'); + std::cout<<"- Password (mostly empty or x):"<> pool_weight) || pool_weight <= 0) + { + std::cin.clear(); + std::cin.ignore(INT_MAX, '\n'); + std::cout << "Invalid weight. Try 1, 10, 100, etc:" << std::endl; + } + + final = !read_yes_no("- Do you want to add another pool? (y/n)"); + + return "\t{\"pool_address\" : \"" + pool +"\", \"wallet_address\" : \"" + userName + "\", \"pool_password\" : \"" + + passwd + "\", \"use_nicehash\" : " + bool_to_str(nicehash) + ", \"use_tls\" : " + bool_to_str(tls) + + ", \"tls_fingerprint\" : \"\", \"pool_weight\" : " + std::to_string(pool_weight) + " },\n"; +} + +void do_guided_config(bool userSetPasswd) +{ + using namespace xmrstak; + + // load the template of the backend config into a char variable + const char *tpl = + #include "../config.tpl" + ; + + configEditor configTpl{}; + configTpl.set(std::string(tpl)); + std::cout<<"Please enter:"<> tmp; + std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower); + } + currency = tmp; + } + + auto& pool = params::inst().poolURL; + bool userSetPool = true; + if(pool.empty()) + { + userSetPool = false; + if(currency == "monero") + std::cout<<"- Pool address: e.g. pool.usxmrpool.com:3333"<> pool; + } + + auto& userName = params::inst().poolUsername; + if(userName.empty()) + { + std::cout<<"- Username (wallet address or pool login):"<> userName; + } + + auto& passwd = params::inst().poolPasswd; + if(passwd.empty() && (!userSetPasswd)) + { + // clear everything from stdin to allow an empty password + std::cin.clear(); std::cin.ignore(INT_MAX,'\n'); + std::cout<<"- Password (mostly empty or x):"<> pool_weight) || pool_weight <= 0) + { + std::cin.clear(); + std::cin.ignore(INT_MAX, '\n'); + std::cout << "Invalid weight. Try 1, 10, 100, etc:" << std::endl; + } + } + else + pool_weight = 1; + + std::string pool_table; + pool_table += "\t{\"pool_address\" : \"" + pool +"\", \"wallet_address\" : \"" + userName + "\", \"pool_password\" : \"" + + passwd + "\", \"use_nicehash\" : " + bool_to_str(nicehash) + ", \"use_tls\" : " + bool_to_str(tls) + + ", \"tls_fingerprint\" : \"\", \"pool_weight\" : " + std::to_string(pool_weight) + " },\n"; + + if(multipool) + { + bool final; + do + { + pool_table += get_multipool_entry(final); + } + while(!final); + } + + configTpl.replace("POOLCONF", pool_table); + configTpl.replace("CURRENCY", currency); + configTpl.write(params::inst().configFile); + std::cout<<"Configuration stored in file '"<> tmp; - } - currency = tmp; - } - auto& pool = params::inst().poolURL; - if(pool.empty()) - { - if(xmrstak::strcmp_i(currency, "monero")) - std::cout<<"- pool address: e.g. pool.usxmrpool.com:3333"<> pool; - } - auto& userName = params::inst().poolUsername; - if(userName.empty()) - { - std::cout<<"- user name (wallet address or pool login):"<> userName; - } - auto& passwd = params::inst().poolPasswd; - if(passwd.empty() && (!userSetPasswd)) - { - // clear everything from stdin to allow an empty password - std::cin.clear(); std::cin.ignore(INT_MAX,'\n'); - std::cout<<"- password (mostly empty or x):"<parse_config(params::inst().configFile.c_str())) { diff --git a/xmrstak/config.tpl b/xmrstak/config.tpl index 3308354..c06d121 100644 --- a/xmrstak/config.tpl +++ b/xmrstak/config.tpl @@ -1,14 +1,19 @@ R"===( /* - * pool_address - Pool address should be in the form "pool.supportxmr.com:3333". Only stratum pools are supported. - * wallet_address - Your wallet, or pool login. - * pool_password - Can be empty in most cases or "x". + * pool_address - Pool address should be in the form "pool.supportxmr.com:3333". Only stratum pools are supported. + * wallet_address - Your wallet, or pool login. + * pool_password - Can be empty in most cases or "x". + * use_nicehash - Limit the nonce to 3 bytes as required by nicehash. + * use_tls - This option will make us connect using Transport Layer Security. + * tls_fingerprint - Server's SHA256 fingerprint. If this string is non-empty then we will check the server's cert against it. + * pool_weight - Pool weight is a number telling the miner how important the pool is. Miner will mine mostly at the pool + * with the highest weight, unless the pool fails. Weight must be an integer larger than 0. * * We feature pools up to 1MH/s. For a more complete list see M5M400's pool list at www.moneropools.com */ -"pool_address" : "POOLURL", -"wallet_address" : "POOLUSER", -"pool_password" : "POOLPASSWD", +"pool_list" : +[ +POOLCONF], /* * currency to mine @@ -31,7 +36,7 @@ R"===( * don't mine while the connection is lost, so your computer's power usage goes down to idle. */ "call_timeout" : 10, -"retry_time" : 10, +"retry_time" : 30, "giveup_limit" : 0, /* @@ -111,25 +116,13 @@ R"===( "use_slow_memory" : "warn", /* - * NiceHash mode - * nicehash_nonce - Limit the nonce to 3 bytes as required by nicehash. This cuts all the safety margins, and - * if a block isn't found within 30 minutes then you might run into nonce collisions. Number - * of threads in this mode is hard-limited to 32. - */ -"nicehash_nonce" : false, - -/* * TLS Settings * If you need real security, make sure tls_secure_algo is enabled (otherwise MITM attack can downgrade encryption * to trivially breakable stuff like DES and MD5), and verify the server's fingerprint through a trusted channel. * - * use_tls - This option will make us connect using Transport Layer Security. * tls_secure_algo - Use only secure algorithms. This will make us quit with an error if we can't negotiate a secure algo. - * tls_fingerprint - Server's SHA256 fingerprint. If this string is non-empty then we will check the server's cert against it. */ -"use_tls" : false, "tls_secure_algo" : true, -"tls_fingerprint" : "", /* * Daemon mode @@ -145,7 +138,7 @@ R"===( * each output line immediately. This can cause delays when running in background. * Set this option to true to flush stdout after each line, so it can be read immediately. */ - "flush_stdout" : false, +"flush_stdout" : false, /* * Output file @@ -172,4 +165,4 @@ R"===( "prefer_ipv4" : true, )===" - \ No newline at end of file + diff --git a/xmrstak/jconf.cpp b/xmrstak/jconf.cpp index c82865d..ec1233a 100644 --- a/xmrstak/jconf.cpp +++ b/xmrstak/jconf.cpp @@ -32,6 +32,10 @@ #include #include #include +#include +#include +#include +#include #ifdef _WIN32 #define strcasecmp _stricmp @@ -47,9 +51,9 @@ using namespace rapidjson; * This enum needs to match index in oConfigValues, otherwise we will get a runtime error */ enum configEnum { - bTlsMode, bTlsSecureAlgo, sTlsFingerprint, sPoolAddr, sWalletAddr, sPoolPwd,sCurrency, - iCallTimeout, iNetRetry, iGiveUpLimit, iVerboseLevel, iAutohashTime,bFlushStdout, - bDaemonMode, sOutputFile, iHttpdPort, bPreferIpv4, bNiceHashMode, bAesOverride, sUseSlowMem }; + aPoolList, bTlsSecureAlgo, sCurrency, iCallTimeout, iNetRetry, iGiveUpLimit, iVerboseLevel, iAutohashTime, + bFlushStdout, bDaemonMode, sOutputFile, iHttpdPort, bPreferIpv4, bAesOverride, sUseSlowMem +}; struct configVal { configEnum iName; @@ -60,12 +64,8 @@ struct configVal { // Same order as in configEnum, as per comment above // kNullType means any type configVal oConfigValues[] = { - { bTlsMode, "use_tls", kTrueType }, + { aPoolList, "pool_list", kArrayType }, { bTlsSecureAlgo, "tls_secure_algo", kTrueType }, - { sTlsFingerprint, "tls_fingerprint", kStringType }, - { sPoolAddr, "pool_address", kStringType }, - { sWalletAddr, "wallet_address", kStringType }, - { sPoolPwd, "pool_password", kStringType }, { sCurrency, "currency", kStringType }, { iCallTimeout, "call_timeout", kNumberType }, { iNetRetry, "retry_time", kNumberType }, @@ -77,7 +77,6 @@ configVal oConfigValues[] = { { sOutputFile, "output_file", kStringType }, { iHttpdPort, "httpd_port", kNumberType }, { bPreferIpv4, "prefer_ipv4", kTrueType }, - { bNiceHashMode, "nicehash_nonce", kTrueType }, { bAesOverride, "aes_override", kNullType }, { sUseSlowMem, "use_slow_memory", kStringType } }; @@ -113,44 +112,54 @@ jconf::jconf() prv = new opaque_private(); } -bool jconf::GetTlsSetting() +uint64_t jconf::GetPoolCount() { - return prv->configValues[bTlsMode]->GetBool(); -} - -bool jconf::TlsSecureAlgos() -{ - return prv->configValues[bTlsSecureAlgo]->GetBool(); -} - -const char* jconf::GetTlsFingerprint() -{ - return prv->configValues[sTlsFingerprint]->GetString(); -} - -const char* jconf::GetPoolAddress() -{ - auto& poolURL = xmrstak::params::inst().poolURL; - if(poolURL.empty()) - poolURL = prv->configValues[sPoolAddr]->GetString(); - return poolURL.c_str(); + if(prv->configValues[aPoolList]->IsArray()) + return prv->configValues[aPoolList]->Size(); + else + return 0; } -const char* jconf::GetPoolPwd() +bool jconf::GetPoolConfig(size_t id, pool_cfg& cfg) { - auto& poolPasswd = xmrstak::params::inst().poolPasswd; - if(poolPasswd.empty()) - poolPasswd = prv->configValues[sPoolPwd]->GetString(); - return poolPasswd.c_str(); + if(id >= GetPoolCount()) + return false; + typedef const Value* cval; + cval jaddr, jlogin, jpasswd, jnicehash, jtls, jtlsfp, jwt; + const Value& oThdConf = prv->configValues[aPoolList]->GetArray()[id]; + + /* We already checked presence and types */ + jaddr = GetObjectMember(oThdConf, "pool_address"); + jlogin = GetObjectMember(oThdConf, "wallet_address"); + jpasswd = GetObjectMember(oThdConf, "pool_password"); + jnicehash = GetObjectMember(oThdConf, "use_nicehash"); + jtls = GetObjectMember(oThdConf, "use_tls"); + jtlsfp = GetObjectMember(oThdConf, "tls_fingerprint"); + jwt = GetObjectMember(oThdConf, "pool_weight"); + + cfg.sPoolAddr = jaddr->GetString(); + cfg.sWalletAddr = jlogin->GetString(); + cfg.sPasswd = jpasswd->GetString(); + cfg.nicehash = jnicehash->GetBool(); + cfg.tls = jtls->GetBool(); + cfg.tls_fingerprint = jtlsfp->GetString(); + cfg.raw_weight = jwt->GetUint64(); + + size_t dlt = wt_max - wt_min; + if(dlt != 0) + { + /* Normalise weights between 0 and 9.9 */ + cfg.weight = double(cfg.raw_weight - wt_min) * 9.9; + cfg.weight /= dlt; + } + else /* Special case - user selected same weights for everything */ + cfg.weight = 0.0; } -const char* jconf::GetWalletAddress() +bool jconf::TlsSecureAlgos() { - auto& poolUsername = xmrstak::params::inst().poolUsername; - if(poolUsername.empty()) - poolUsername = prv->configValues[sWalletAddr]->GetString(); - return poolUsername.c_str(); + return prv->configValues[bTlsSecureAlgo]->GetBool(); } const std::string jconf::GetCurrency() @@ -237,12 +246,6 @@ const char* jconf::GetOutputFile() return prv->configValues[sOutputFile]->GetString(); } -bool jconf::NiceHashMode() -{ - return prv->configValues[bNiceHashMode]->GetBool(); -} - - void jconf::cpuid(uint32_t eax, int32_t ecx, int32_t val[4]) { memset(val, 0, sizeof(int32_t)*4); @@ -385,6 +388,60 @@ bool jconf::parse_config(const char* sFilename) } } + size_t pool_cnt = prv->configValues[aPoolList]->Size(); + if(pool_cnt == 0) + { + printer::inst()->print_msg(L0, "Invalid config file. pool_list must not be empty."); + return false; + } + + std::vector pool_weights; + pool_weights.reserve(pool_cnt); + + const char* aPoolValues[] = { "pool_address", "wallet_address", "pool_password", "use_nicehash", "use_tls", "tls_fingerprint", "pool_weight" }; + Type poolValTypes[] = { kStringType, kStringType, kStringType, kTrueType, kTrueType, kStringType, kNumberType }; + + constexpr size_t pvcnt = sizeof(aPoolValues)/sizeof(aPoolValues[0]); + for(uint32_t i=0; i < pool_cnt; i++) + { + const Value& oThdConf = prv->configValues[aPoolList]->GetArray()[i]; + + if(!oThdConf.IsObject()) + { + printer::inst()->print_msg(L0, "Invalid config file. pool_list must contain objects."); + return false; + } + + for(uint32_t j=0; j < pvcnt; j++) + { + const Value* v; + if((v = GetObjectMember(oThdConf, aPoolValues[j])) == nullptr) + { + printer::inst()->print_msg(L0, "Invalid config file. Pool %u does not have the value %s.", i, aPoolValues[j]); + return false; + } + + if(!checkType(v->GetType(), poolValTypes[j])) + { + printer::inst()->print_msg(L0, "Invalid config file. Value %s for pool %u has unexpected type.", aPoolValues[j], i); + return false; + } + } + + const Value* jwt = GetObjectMember(oThdConf, "pool_weight"); + size_t wt; + if(!jwt->IsUint64() || (wt = jwt->GetUint64()) == 0) + { + printer::inst()->print_msg(L0, "Invalid pool list for pool %u. Pool weight needs to be an integer larger than zero.", i); + return false; + } + + pool_weights.emplace_back(wt); + } + + wt_max = *std::max_element(pool_weights.begin(), pool_weights.end()); + wt_min = *std::min_element(pool_weights.begin(), pool_weights.end()); + if(!prv->configValues[iCallTimeout]->IsUint64() || !prv->configValues[iNetRetry]->IsUint64() || !prv->configValues[iGiveUpLimit]->IsUint64()) @@ -394,6 +451,13 @@ bool jconf::parse_config(const char* sFilename) return false; } + if(prv->configValues[iCallTimeout]->GetUint64() < 2 || prv->configValues[iNetRetry]->GetUint64() < 2) + { + printer::inst()->print_msg(L0, + "Invalid config file. call_timeout and retry_time need to be larger than 1 second."); + return false; + } + if(!prv->configValues[iVerboseLevel]->IsUint64() || !prv->configValues[iAutohashTime]->IsUint64()) { printer::inst()->print_msg(L0, @@ -417,15 +481,6 @@ bool jconf::parse_config(const char* sFilename) } #endif // CONF_NO_TLS - /* \todo check in the cpu backend if we have more than 32 worker - * keep in mined that we have change the why how the nonce is calculated (reverse thread index) - if(NiceHashMode() && GetThreadCount() >= 32) - { - printer::inst()->print_msg(L0, "You need to use less than 32 threads in NiceHash mode."); - return false; - } - */ - if(prv->configValues[bAesOverride]->IsBool()) bHaveAes = prv->configValues[bAesOverride]->GetBool(); diff --git a/xmrstak/jconf.hpp b/xmrstak/jconf.hpp index 48b47b5..b68ef38 100644 --- a/xmrstak/jconf.hpp +++ b/xmrstak/jconf.hpp @@ -19,12 +19,23 @@ public: }; bool parse_config(const char* sFilename = xmrstak::params::inst().configFile.c_str()); - - struct thd_cfg { - bool bDoubleMode; - bool bNoPrefetch; - long long iCpuAff; + + struct pool_cfg { + const char* sPoolAddr; + const char* sWalletAddr; + const char* sPasswd; + bool nicehash; + bool tls; + const char* tls_fingerprint; + size_t raw_weight; + double weight; }; + + size_t wt_max; + size_t wt_min; + + uint64_t GetPoolCount(); + bool GetPoolConfig(size_t id, pool_cfg& cfg); enum slow_mem_cfg { always_use, @@ -34,13 +45,8 @@ public: unknown_value }; - bool GetTlsSetting(); bool TlsSecureAlgos(); - const char* GetTlsFingerprint(); - - const char* GetPoolAddress(); - const char* GetPoolPwd(); - const char* GetWalletAddress(); + const std::string GetCurrency(); bool IsCurrencyMonero(); @@ -59,9 +65,6 @@ public: bool PreferIpv4(); - - bool NiceHashMode(); - inline bool HaveHardwareAes() { return bHaveAes; } static void cpuid(uint32_t eax, int32_t ecx, int32_t val[4]); diff --git a/xmrstak/misc/executor.cpp b/xmrstak/misc/executor.cpp index b469dc2..931e2aa 100644 --- a/xmrstak/misc/executor.cpp +++ b/xmrstak/misc/executor.cpp @@ -39,6 +39,7 @@ #include #include #include +#include #include #include @@ -58,23 +59,17 @@ void executor::push_timed_event(ex_event&& ev, size_t sec) void executor::ex_clock_thd() { - size_t iSwitchPeriod = sec_to_ticks(iDevDonatePeriod); - size_t iDevPortion = (size_t)floor(((double)iSwitchPeriod) * fDevDonationLevel); - - //No point in bothering with less than 10 sec - if(iDevPortion < sec_to_ticks(10)) - iDevPortion = 0; - - //Add 2 seconds to compensate for connect - if(iDevPortion != 0) - iDevPortion += sec_to_ticks(2); - + size_t tick = 0; while (true) { std::this_thread::sleep_for(std::chrono::milliseconds(size_t(iTickTime))); push_event(ex_event(EV_PERF_TICK)); + //Eval pool choice every fourth tick + if((tick++ & 0x03) == 0) + push_event(ex_event(EV_EVAL_POOL_CHOICE)); + // Service timed events std::unique_lock lck(timed_event_mutex); std::list::iterator ev = lTimedEvents.begin(); @@ -90,49 +85,190 @@ void executor::ex_clock_thd() ev++; } lck.unlock(); + } +} + +bool executor::get_live_pools(std::vector& eval_pools, bool is_dev) +{ + size_t limit = jconf::inst()->GetGiveUpLimit(); + size_t wait = jconf::inst()->GetNetRetry(); - if(iDevPortion == 0) + if(limit == 0 || is_dev) limit = (-1); //No limit = limit of 2^64-1 + + size_t pool_count = 0; + size_t over_limit = 0; + for(jpsock& pool : pools) + { + if(pool.is_dev_pool() != is_dev) continue; - iSwitchPeriod--; - if(iSwitchPeriod == 0) - { - push_event(ex_event(EV_SWITCH_POOL, usr_pool_id)); - iSwitchPeriod = sec_to_ticks(iDevDonatePeriod); - } - else if(iSwitchPeriod == iDevPortion) + // Only eval live pools + size_t num, dtime; + if(pool.get_disconnects(num, dtime)) + set_timestamp(); + + if(dtime == 0 || (dtime >= wait && num <= limit)) + eval_pools.emplace_back(&pool); + + pool_count++; + if(num > limit) + over_limit++; + } + + if(eval_pools.size() == 0) + { + if(!is_dev) { - push_event(ex_event(EV_SWITCH_POOL, dev_pool_id)); + if(xmrstak::globalStates::inst().pool_id != invalid_pool_id) + { + printer::inst()->print_msg(L0, "All pools are dead. Idling..."); + auto work = xmrstak::miner_work(); + xmrstak::pool_data dat; + xmrstak::globalStates::inst().switch_work(work, dat); + } + + if(over_limit == pool_count) + { + printer::inst()->print_msg(L0, "All pools are over give up limit. Exitting."); + exit(0); + } + + return false; } + else + return get_live_pools(eval_pools, false); } + + return true; } -void executor::sched_reconnect() +/* + * This event is called by the timer and whenever something relevant happens. + * The job here is to decide if we want to connect, disconnect, or switch jobs (or do nothing) + */ +void executor::eval_pool_choice() { - iReconnectAttempts++; - size_t iLimit = jconf::inst()->GetGiveUpLimit(); - if(iLimit != 0 && iReconnectAttempts > iLimit) + std::vector eval_pools; + eval_pools.reserve(pools.size()); + + bool dev_time = is_dev_time(); + if(!get_live_pools(eval_pools, dev_time)) + return; + + size_t running = 0; + for(jpsock* pool : eval_pools) { - printer::inst()->print_msg(L0, "Give up limit reached. Exitting."); - exit(0); + if(pool->is_running()) + running++; } - long long unsigned int rt = jconf::inst()->GetNetRetry(); - printer::inst()->print_msg(L1, "Pool connection lost. Waiting %lld s before retry (attempt %llu).", - rt, int_port(iReconnectAttempts)); + // Special case - if we are without a pool, connect to all find a live pool asap + if(running == 0) + { + if(dev_time) + printer::inst()->print_msg(L1, "Fast-connecting to dev pool ..."); - auto work = xmrstak::miner_work(); - xmrstak::pool_data dat; + for(jpsock* pool : eval_pools) + { + if(pool->can_connect()) + { + if(!dev_time) + printer::inst()->print_msg(L1, "Fast-connecting to %s pool ...", pool->get_pool_addr()); + std::string error; + if(!pool->connect(error)) + log_socket_error(pool, std::move(error)); + } + } + + return; + } + + std::sort(eval_pools.begin(), eval_pools.end(), [](jpsock* a, jpsock* b) { return b->get_pool_weight(true) < a->get_pool_weight(true); }); + jpsock* goal = eval_pools[0]; - xmrstak::globalStates::inst().switch_work(work, dat); + if(goal->get_pool_id() != xmrstak::globalStates::inst().pool_id) + { + if(!goal->is_running() && goal->can_connect()) + { + if(dev_time) + printer::inst()->print_msg(L1, "Connecting to dev pool ..."); + else + printer::inst()->print_msg(L1, "Connecting to %s pool ...", goal->get_pool_addr()); + + std::string error; + if(!goal->connect(error)) + log_socket_error(goal, std::move(error)); + return; + } + + if(goal->is_logged_in()) + { + pool_job oPoolJob; + if(!goal->get_current_job(oPoolJob)) + { + goal->disconnect(); + return; + } - push_timed_event(ex_event(EV_RECONNECT, usr_pool_id), rt); + size_t prev_pool_id = current_pool_id; + current_pool_id = goal->get_pool_id(); + on_pool_have_job(current_pool_id, oPoolJob); + + jpsock* prev_pool = pick_pool_by_id(prev_pool_id); + if(prev_pool == nullptr || (!prev_pool->is_dev_pool() && !goal->is_dev_pool())) + reset_stats(); + + if(goal->is_dev_pool() && (prev_pool != nullptr && !prev_pool->is_dev_pool())) + last_usr_pool_id = prev_pool_id; + else + last_usr_pool_id = invalid_pool_id; + + return; + } + } + else + { + /* All is good - but check if we can do better */ + std::sort(eval_pools.begin(), eval_pools.end(), [](jpsock* a, jpsock* b) { return b->get_pool_weight(false) < a->get_pool_weight(false); }); + jpsock* goal2 = eval_pools[0]; + + if(goal->get_pool_id() != goal2->get_pool_id()) + { + if(!goal2->is_running() && goal2->can_connect()) + { + printer::inst()->print_msg(L1, "Background-connect to %s pool ...", goal2->get_pool_addr()); + std::string error; + if(!goal2->connect(error)) + log_socket_error(goal2, std::move(error)); + return; + } + } + } + + if(!dev_time) + { + for(jpsock& pool : pools) + { + if(goal->is_logged_in() && pool.is_running() && pool.get_pool_id() != goal->get_pool_id()) + pool.disconnect(true); + + if(pool.is_dev_pool() && pool.is_running()) + pool.disconnect(true); + } + } } -void executor::log_socket_error(std::string&& sError) +void executor::log_socket_error(jpsock* pool, std::string&& sError) { + std::string pool_name; + pool_name.reserve(128); + pool_name.append("[").append(pool->get_pool_addr()).append("] "); + sError.insert(0, pool_name); + vSocketLog.emplace_back(std::move(sError)); printer::inst()->print_msg(L1, "SOCKET ERROR - %s", vSocketLog.back().msg.c_str()); + + push_event(ex_event(EV_EVAL_POOL_CHOICE)); } void executor::log_result_error(std::string&& sError) @@ -172,70 +308,48 @@ jpsock* executor::pick_pool_by_id(size_t pool_id) if(pool_id == invalid_pool_id) return nullptr; - if(pool_id == dev_pool_id) - return dev_pool; - else - return usr_pool; + for(jpsock& pool : pools) + if(pool.get_pool_id() == pool_id) + return &pool; + + return nullptr; } void executor::on_sock_ready(size_t pool_id) { jpsock* pool = pick_pool_by_id(pool_id); + + if(pool->is_dev_pool()) + printer::inst()->print_msg(L1, "Dev pool connected. Logging in..."); + else + printer::inst()->print_msg(L1, "Pool %s connected. Logging in...", pool->get_pool_addr()); - if(pool_id == dev_pool_id) - { - if(::jconf::inst()->IsCurrencyMonero()) - { - if(!pool->cmd_login("", "")) - pool->disconnect(); - } - else - { - if(!pool->cmd_login("WmsvqXDu7Fw5eAEZr1euJH3ycad55NxFd82PfhLR9Zi1Nq5S74zk63EA8fyMS8BQNR94os9N9aah87inKkumNJ7G2d7qTpRLN", "x")) - pool->disconnect(); - } - - current_pool_id = dev_pool_id; - printer::inst()->print_msg(L1, "Dev pool logged in. Switching work."); - return; - } - - printer::inst()->print_msg(L1, "Connected. Logging in..."); - - if (!pool->cmd_login(jconf::inst()->GetWalletAddress(), jconf::inst()->GetPoolPwd())) + if(!pool->cmd_login()) { if(!pool->have_sock_error()) { - log_socket_error(pool->get_call_error()); + log_socket_error(pool, pool->get_call_error()); pool->disconnect(); } } - else - { - iReconnectAttempts = 0; - reset_stats(); - } } -void executor::on_sock_error(size_t pool_id, std::string&& sError) +void executor::on_sock_error(size_t pool_id, std::string&& sError, bool silent) { jpsock* pool = pick_pool_by_id(pool_id); - if(pool_id == dev_pool_id) - { - pool->disconnect(); - - if(current_pool_id != dev_pool_id) - return; + pool->disconnect(); + + if(pool_id == current_pool_id) + current_pool_id = invalid_pool_id; - printer::inst()->print_msg(L1, "Dev pool connection error. Switching work."); - on_switch_pool(usr_pool_id); + if(silent) return; - } - log_socket_error(std::move(sError)); - pool->disconnect(); - sched_reconnect(); + if(!pool->is_dev_pool()) + log_socket_error(pool, std::move(sError)); + else + printer::inst()->print_msg(L1, "Dev pool socket error - mining on user pool..."); } void executor::on_pool_have_job(size_t pool_id, pool_job& oPoolJob) @@ -245,9 +359,8 @@ void executor::on_pool_have_job(size_t pool_id, pool_job& oPoolJob) jpsock* pool = pick_pool_by_id(pool_id); - xmrstak::miner_work oWork(oPoolJob.sJobID, oPoolJob.bWorkBlob, oPoolJob.iWorkLen, oPoolJob.iTarget, - pool_id != dev_pool_id && ::jconf::inst()->NiceHashMode(), pool_id); - + xmrstak::miner_work oWork(oPoolJob.sJobID, oPoolJob.bWorkBlob, oPoolJob.iWorkLen, oPoolJob.iTarget, pool->is_nicehash(), pool_id); + xmrstak::pool_data dat; dat.iSavedNonce = oPoolJob.iSavedNonce; dat.pool_id = pool_id; @@ -261,7 +374,7 @@ void executor::on_pool_have_job(size_t pool_id, pool_job& oPoolJob) prev_pool->save_nonce(dat.iSavedNonce); } - if(pool_id == dev_pool_id) + if(pool->is_dev_pool()) return; if(iPoolDiff != pool->get_current_diff()) @@ -270,17 +383,22 @@ void executor::on_pool_have_job(size_t pool_id, pool_job& oPoolJob) printer::inst()->print_msg(L2, "Difficulty changed. Now: %llu.", int_port(iPoolDiff)); } - if(dat.pool_id == pool_id) - printer::inst()->print_msg(L3, "New block detected."); + if(dat.pool_id != pool_id) + { + if(dat.pool_id == invalid_pool_id) + printer::inst()->print_msg(L2, "Pool logged in."); + else + printer::inst()->print_msg(L2, "Pool switched."); + } else - printer::inst()->print_msg(L3, "Pool switched."); + printer::inst()->print_msg(L3, "New block detected."); } void executor::on_miner_result(size_t pool_id, job_result& oResult) { jpsock* pool = pick_pool_by_id(pool_id); - if(pool_id == dev_pool_id) + if(pool->is_dev_pool()) { //Ignore errors silently if(pool->is_running() && pool->is_logged_in()) @@ -331,64 +449,6 @@ void executor::on_miner_result(size_t pool_id, job_result& oResult) } } -void executor::on_reconnect(size_t pool_id) -{ - jpsock* pool = pick_pool_by_id(pool_id); - - std::string error; - if(pool_id == dev_pool_id) - return; - - printer::inst()->print_msg(L1, "Connecting to pool %s ...", jconf::inst()->GetPoolAddress()); - - if(!pool->connect(jconf::inst()->GetPoolAddress(), error)) - { - log_socket_error(std::move(error)); - sched_reconnect(); - } -} - -void executor::on_switch_pool(size_t pool_id) -{ - if(pool_id == current_pool_id) - return; - - jpsock* pool = pick_pool_by_id(pool_id); - if(pool_id == dev_pool_id) - { - std::string error; - - // If it fails, it fails, we carry on on the usr pool - // as we never receive further events - printer::inst()->print_msg(L1, "Connecting to dev pool..."); - std::string dev_pool_addr; - if(::jconf::inst()->IsCurrencyMonero()) - dev_pool_addr = jconf::inst()->GetTlsSetting() ? "donate.xmr-stak.net:6666" : "donate.xmr-stak.net:3333"; - else - dev_pool_addr = jconf::inst()->GetTlsSetting() ? "mine.aeon-pool.com:443" : "mine.aeon-pool.com:5555"; - if(!pool->connect(dev_pool_addr.c_str(), error)) - printer::inst()->print_msg(L1, "Error connecting to dev pool. Staying with user pool."); - } - else - { - printer::inst()->print_msg(L1, "Switching back to user pool."); - - current_pool_id = pool_id; - pool_job oPoolJob; - - if(!pool->get_current_job(oPoolJob)) - { - pool->disconnect(); - return; - } - - on_pool_have_job(current_pool_id, oPoolJob); - - if(dev_pool->is_running()) - push_timed_event(ex_event(EV_DEV_POOL_EXIT), 5); - } -} - void executor::ex_main() { assert(1000 % iTickTime == 0); @@ -406,15 +466,36 @@ void executor::ex_main() telem = new xmrstak::telemetry(pvThreads->size()); - current_pool_id = usr_pool_id; - usr_pool = new jpsock(usr_pool_id, jconf::inst()->GetTlsSetting()); - dev_pool = new jpsock(dev_pool_id, jconf::inst()->GetTlsSetting()); + set_timestamp(); + size_t pc = jconf::inst()->GetPoolCount(); + bool tls = true; + for(size_t i=0; i < pc; i++) + { + jconf::pool_cfg cfg; + jconf::inst()->GetPoolConfig(i, cfg); + if(!cfg.tls) tls = false; + pools.emplace_back(i+1, cfg.sPoolAddr, cfg.sWalletAddr, cfg.sPasswd, cfg.weight, false, cfg.tls, cfg.tls_fingerprint, cfg.nicehash); + } + + if(jconf::inst()->IsCurrencyMonero()) + { + if(tls) + pools.emplace_front(0, "donate.xmr-stak.net:6666", "", "", 0.0, true, true, "", false); + else + pools.emplace_front(0, "donate.xmr-stak.net:3333", "", "", 0.0, true, false, "", false); + } + else + { + if(tls) + pools.emplace_front(0, "donate.xmr-stak.net:7777", "", "", 0.0, true, true, "", false); + else + pools.emplace_front(0, "donate.xmr-stak.net:4444", "", "", 0.0, true, false, "", false); + } ex_event ev; std::thread clock_thd(&executor::ex_clock_thd, this); - //This will connect us to the pool for the first time - push_event(ex_event(EV_RECONNECT, usr_pool_id)); + eval_pool_choice(); // Place the default success result at position 0, it needs to // be here even if our first result is a failure @@ -435,7 +516,7 @@ void executor::ex_main() break; case EV_SOCK_ERROR: - on_sock_error(ev.iPoolId, std::move(ev.sSocketError)); + on_sock_error(ev.iPoolId, std::move(ev.oSocketError.sSocketError), ev.oSocketError.silent); break; case EV_POOL_HAVE_JOB: @@ -446,16 +527,8 @@ void executor::ex_main() on_miner_result(ev.iPoolId, ev.oJobResult); break; - case EV_RECONNECT: - on_reconnect(ev.iPoolId); - break; - - case EV_SWITCH_POOL: - on_switch_pool(ev.iPoolId); - break; - - case EV_DEV_POOL_EXIT: - dev_pool->disconnect(); + case EV_EVAL_POOL_CHOICE: + eval_pool_choice(); break; case EV_PERF_TICK: @@ -486,7 +559,7 @@ void executor::ex_main() if(normal && fHighestHps < fHps) fHighestHps = fHps; } - break; + break; case EV_USR_HASHRATE: case EV_USR_RESULTS: @@ -672,11 +745,13 @@ void executor::connection_report(std::string& out) out.reserve(512); - jpsock* pool = pick_pool_by_id(dev_pool_id + 1); + jpsock* pool = pick_pool_by_id(current_pool_id); + if(pool != nullptr && pool->is_dev_pool()) + pool = pick_pool_by_id(last_usr_pool_id); out.append("CONNECTION REPORT\n"); - out.append("Pool address : ").append(jconf::inst()->GetPoolAddress()).append(1, '\n'); - if (pool->is_running() && pool->is_logged_in()) + out.append("Pool address : ").append(pool != nullptr ? pool->get_pool_addr() : "").append(1, '\n'); + if(pool != nullptr && pool->is_running() && pool->is_logged_in()) out.append("Connected since : ").append(time_format(date, sizeof(date), tPoolConnTime)).append(1, '\n'); else out.append("Connected since : \n"); @@ -833,9 +908,12 @@ void executor::http_connection_report(std::string& out) snprintf(buffer, sizeof(buffer), sHtmlCommonHeader, "Connection Report", "Connection Report"); out.append(buffer); - jpsock* pool = pick_pool_by_id(dev_pool_id + 1); + jpsock* pool = pick_pool_by_id(current_pool_id); + if(pool != nullptr && pool->is_dev_pool()) + pool = pick_pool_by_id(last_usr_pool_id); + const char* cdate = "not connected"; - if (pool->is_running() && pool->is_logged_in()) + if (pool != nullptr && pool->is_running() && pool->is_logged_in()) cdate = time_format(date, sizeof(date), tPoolConnTime); size_t n_calls = iPoolCallTimes.size(); @@ -848,7 +926,7 @@ void executor::http_connection_report(std::string& out) } snprintf(buffer, sizeof(buffer), sHtmlConnectionBodyHigh, - jconf::inst()->GetPoolAddress(), + pool != nullptr ? pool->get_pool_addr() : "not connected", cdate, ping_time); out.append(buffer); @@ -918,10 +996,12 @@ void executor::http_json_report(std::string& out) for(size_t i=1; i < ln; i++) iTotalRes += vMineResults[i].count; - jpsock* pool = pick_pool_by_id(dev_pool_id + 1); + jpsock* pool = pick_pool_by_id(current_pool_id); + if(pool != nullptr && pool->is_dev_pool()) + pool = pick_pool_by_id(last_usr_pool_id); size_t iConnSec = 0; - if(pool->is_running() && pool->is_logged_in()) + if(pool != nullptr && pool->is_running() && pool->is_logged_in()) { using namespace std::chrono; iConnSec = duration_cast(system_clock::now() - tPoolConnTime).count(); @@ -973,7 +1053,7 @@ void executor::http_json_report(std::string& out) int_port(iPoolDiff), int_port(iGoodRes), int_port(iTotalRes), fAvgResTime, int_port(iPoolHashes), int_port(iTopDiff[0]), int_port(iTopDiff[1]), int_port(iTopDiff[2]), int_port(iTopDiff[3]), int_port(iTopDiff[4]), int_port(iTopDiff[5]), int_port(iTopDiff[6]), int_port(iTopDiff[7]), int_port(iTopDiff[8]), int_port(iTopDiff[9]), - res_error.c_str(), jconf::inst()->GetPoolAddress(), int_port(iConnSec), int_port(iPoolPing), cn_error.c_str()); + res_error.c_str(), pool != nullptr ? pool->get_pool_addr() : "not connected", int_port(iConnSec), int_port(iPoolPing), cn_error.c_str()); out = std::string(bigbuf.get(), bigbuf.get() + bb_len); } diff --git a/xmrstak/misc/executor.hpp b/xmrstak/misc/executor.hpp index d705c27..11c8206 100644 --- a/xmrstak/misc/executor.hpp +++ b/xmrstak/misc/executor.hpp @@ -5,12 +5,14 @@ #include "xmrstak/backend/iBackend.hpp" #include "xmrstak/misc/environment.hpp" #include "xmrstak/net/msgstruct.hpp" +#include "xmrstak/donate-level.hpp" #include #include #include +#include #include - +#include class jpsock; @@ -42,10 +44,6 @@ public: void push_timed_event(ex_event&& ev, size_t sec); void log_result_error(std::string&& sError); - constexpr static size_t invalid_pool_id = 0; - constexpr static size_t dev_pool_id = 1; - constexpr static size_t usr_pool_id = 2; - private: struct timed_event { @@ -55,6 +53,8 @@ private: timed_event(ex_event&& ev, size_t ticks) : event(std::move(ev)), ticks_left(ticks) {} }; + inline void set_timestamp() { dev_timestamp = get_timestamp(); }; + // In miliseconds, has to divide a second (1000ms) into an integer number constexpr static size_t iTickTime = 500; @@ -62,6 +62,17 @@ private: // We will divide up this period according to the config setting constexpr static size_t iDevDonatePeriod = 100 * 60; + inline bool is_dev_time() + { + //Add 2 seconds to compensate for connect + constexpr size_t dev_portion = double(iDevDonatePeriod) * fDevDonationLevel + 2; + + if(dev_portion < 12) //No point in bothering with less than 10s + return false; + + return (get_timestamp() - dev_timestamp) % iDevDonatePeriod >= (iDevDonatePeriod - dev_portion); + }; + std::list lTimedEvents; std::mutex timed_event_mutex; thdq oEventQ; @@ -69,15 +80,14 @@ private: xmrstak::telemetry* telem; std::vector* pvThreads; - size_t current_pool_id; + size_t current_pool_id = invalid_pool_id; + size_t last_usr_pool_id = invalid_pool_id; + size_t dev_timestamp; - jpsock* usr_pool; - jpsock* dev_pool; + std::list pools; jpsock* pick_pool_by_id(size_t pool_id); - bool is_dev_time; - executor(); void ex_main(); @@ -101,8 +111,6 @@ private: std::promise httpReady; std::mutex httpMutex; - size_t iReconnectAttempts = 0; - struct sck_error_log { std::chrono::system_clock::time_point time; @@ -171,17 +179,16 @@ private: double fHighestHps = 0.0; - void log_socket_error(std::string&& sError); + void log_socket_error(jpsock* pool, std::string&& sError); void log_result_ok(uint64_t iActualDiff); - void sched_reconnect(); - void on_sock_ready(size_t pool_id); - void on_sock_error(size_t pool_id, std::string&& sError); + void on_sock_error(size_t pool_id, std::string&& sError, bool silent); void on_pool_have_job(size_t pool_id, pool_job& oPoolJob); void on_miner_result(size_t pool_id, job_result& oResult); - void on_reconnect(size_t pool_id); - void on_switch_pool(size_t pool_id); + void connect_to_pools(std::list& eval_pools); + bool get_live_pools(std::vector& eval_pools, bool is_dev); + void eval_pool_choice(); inline size_t sec_to_ticks(size_t sec) { return sec * (1000 / iTickTime); } }; diff --git a/xmrstak/net/jpsock.cpp b/xmrstak/net/jpsock.cpp index 68b495d..f6f5c1f 100644 --- a/xmrstak/net/jpsock.cpp +++ b/xmrstak/net/jpsock.cpp @@ -94,7 +94,9 @@ struct jpsock::opq_json_val opq_json_val(const Value* val) : val(val) {} }; -jpsock::jpsock(size_t id, bool tls) : pool_id(id) +jpsock::jpsock(size_t id, const char* sAddr, const char* sLogin, const char* sPassword, double pool_weight, bool dev_pool, bool tls, const char* tls_fp, bool nicehash) : + net_addr(sAddr), usr_login(sLogin), usr_pass(sPassword), tls_fp(tls_fp), pool_id(id), pool_weight(pool_weight), pool(dev_pool), nicehash(nicehash), + connect_time(0), connect_attempts(0), disconnect_time(0), quiet_close(false) { sock_init(); @@ -189,7 +191,7 @@ bool jpsock::set_socket_error_strerr(const char* a, int res) void jpsock::jpsock_thread() { jpsock_thd_main(); - executor::inst()->push_event(ex_event(std::move(sSocketError), pool_id)); + executor::inst()->push_event(ex_event(std::move(sSocketError), quiet_close, pool_id)); // If a call is wating, send an error to end it bool bCallWaiting = false; @@ -206,11 +208,16 @@ void jpsock::jpsock_thread() if(bCallWaiting) call_cond.notify_one(); - bRunning = false; bLoggedIn = false; + if(bHaveSocketError && !quiet_close) + disconnect_time = get_timestamp(); + else + disconnect_time = 0; + std::unique_lock(job_mutex); memset(&oCurrentJob, 0, sizeof(oCurrentJob)); + bRunning = false; } bool jpsock::jpsock_thd_main() @@ -417,15 +424,18 @@ bool jpsock::process_pool_job(const opq_json_val* params) return true; } -bool jpsock::connect(const char* sAddr, std::string& sConnectError) +bool jpsock::connect(std::string& sConnectError) { bHaveSocketError = false; sSocketError.clear(); iJobDiff = 0; - - if(sck->set_hostname(sAddr)) + connect_attempts++; + + if(sck->set_hostname(net_addr.c_str())) { bRunning = true; + disconnect_time = 0; + connect_time = get_timestamp(); oRecvThd = new std::thread(&jpsock::jpsock_thread, this); return true; } @@ -434,8 +444,9 @@ bool jpsock::connect(const char* sAddr, std::string& sConnectError) return false; } -void jpsock::disconnect() +void jpsock::disconnect(bool quiet) { + quiet_close = quiet; sck->close(false); if(oRecvThd != nullptr) @@ -446,6 +457,7 @@ void jpsock::disconnect() } sck->close(true); + quiet_close = false; } bool jpsock::cmd_ret_wait(const char* sPacket, opq_json_val& poResult) @@ -493,12 +505,12 @@ bool jpsock::cmd_ret_wait(const char* sPacket, opq_json_val& poResult) return bSuccess; } -bool jpsock::cmd_login(const char* sLogin, const char* sPassword) +bool jpsock::cmd_login() { char cmd_buffer[1024]; snprintf(cmd_buffer, sizeof(cmd_buffer), "{\"method\":\"login\",\"params\":{\"login\":\"%s\",\"pass\":\"%s\",\"agent\":\"" AGENTID_STR "\"},\"id\":1}\n", - sLogin, sPassword); + usr_login.c_str(), usr_pass.c_str()); opq_json_val oResult(nullptr); @@ -541,6 +553,7 @@ bool jpsock::cmd_login(const char* sLogin, const char* sPassword) } bLoggedIn = true; + connect_attempts = 0; return true; } diff --git a/xmrstak/net/jpsock.hpp b/xmrstak/net/jpsock.hpp index e94eaad..db8cd0e 100644 --- a/xmrstak/net/jpsock.hpp +++ b/xmrstak/net/jpsock.hpp @@ -26,20 +26,37 @@ class base_socket; class jpsock { public: - jpsock(size_t id, bool tls); + jpsock(size_t id, const char* sAddr, const char* sLogin, const char* sPassword, double pool_weight, bool dev_pool, bool tls, const char* tls_fp, bool nicehash); ~jpsock(); - bool connect(const char* sAddr, std::string& sConnectError); - void disconnect(); + bool connect(std::string& sConnectError); + void disconnect(bool quiet = false); - bool cmd_login(const char* sLogin, const char* sPassword); + bool cmd_login(); bool cmd_submit(const char* sJobId, uint32_t iNonce, const uint8_t* bResult); static bool hex2bin(const char* in, unsigned int len, unsigned char* out); static void bin2hex(const unsigned char* in, unsigned int len, char* out); + inline double get_pool_weight(bool gross_weight) + { + double ret = pool_weight; + if(gross_weight && bRunning) + ret += 10.0; + if(gross_weight && bLoggedIn) + ret += 10.0; + return ret; + } + + inline size_t can_connect() { return get_timestamp() != connect_time; } inline bool is_running() { return bRunning; } inline bool is_logged_in() { return bLoggedIn; } + inline bool is_dev_pool() { return pool; } + inline size_t get_pool_id() { return pool_id; } + inline bool get_disconnects(size_t& att, size_t& time) { att = connect_attempts; time = disconnect_time != 0 ? get_timestamp() - disconnect_time + 1 : 0; return pool && usr_login[0]; } + inline const char* get_pool_addr() { return net_addr.c_str(); } + inline const char* get_tls_fp() { return tls_fp.c_str(); } + inline bool is_nicehash() { return nicehash; } std::string&& get_call_error(); bool have_sock_error() { return bHaveSocketError; } @@ -53,8 +70,6 @@ public: void save_nonce(uint32_t nonce); bool get_current_job(pool_job& job); - size_t pool_id; - bool set_socket_error(const char* a); bool set_socket_error(const char* a, const char* b); bool set_socket_error(const char* a, size_t len); @@ -62,8 +77,23 @@ public: bool set_socket_error_strerr(const char* a, int res); private: + std::string net_addr; + std::string usr_login; + std::string usr_pass; + std::string tls_fp; + + size_t pool_id; + double pool_weight; + bool pool; + bool nicehash; + + size_t connect_time = 0; + std::atomic connect_attempts; + std::atomic disconnect_time; + std::atomic bRunning; std::atomic bLoggedIn; + std::atomic quiet_close; uint8_t* bJsonRecvMem; uint8_t* bJsonParseMem; diff --git a/xmrstak/net/msgstruct.hpp b/xmrstak/net/msgstruct.hpp index 82b59c1..01aa76c 100644 --- a/xmrstak/net/msgstruct.hpp +++ b/xmrstak/net/msgstruct.hpp @@ -39,11 +39,33 @@ struct job_result } }; +struct sock_err +{ + std::string sSocketError; + bool silent; + + sock_err() {} + sock_err(std::string&& err, bool silent) : sSocketError(std::move(err)), silent(silent) { } + sock_err(sock_err&& from) : sSocketError(std::move(from.sSocketError)), silent(from.silent) {} + + sock_err& operator=(sock_err&& from) + { + assert(this != &from); + sSocketError = std::move(from.sSocketError); + silent = from.silent; + return *this; + } + + ~sock_err() { } + + sock_err(sock_err const&) = delete; + sock_err& operator=(sock_err const&) = delete; +}; enum ex_event_name { EV_INVALID_VAL, EV_SOCK_READY, EV_SOCK_ERROR, - EV_POOL_HAVE_JOB, EV_MINER_HAVE_RESULT, EV_PERF_TICK, EV_RECONNECT, - EV_SWITCH_POOL, EV_DEV_POOL_EXIT, EV_USR_HASHRATE, EV_USR_RESULTS, EV_USR_CONNSTAT, - EV_HASHRATE_LOOP, EV_HTML_HASHRATE, EV_HTML_RESULTS, EV_HTML_CONNSTAT, EV_HTML_JSON }; + EV_POOL_HAVE_JOB, EV_MINER_HAVE_RESULT, EV_PERF_TICK, EV_EVAL_POOL_CHOICE, + EV_USR_HASHRATE, EV_USR_RESULTS, EV_USR_CONNSTAT, EV_HASHRATE_LOOP, + EV_HTML_HASHRATE, EV_HTML_RESULTS, EV_HTML_CONNSTAT, EV_HTML_JSON }; /* This is how I learned to stop worrying and love c++11 =). @@ -64,11 +86,11 @@ struct ex_event { pool_job oPoolJob; job_result oJobResult; - std::string sSocketError; + sock_err oSocketError; }; ex_event() { iName = EV_INVALID_VAL; iPoolId = 0;} - ex_event(std::string&& err, size_t id) : iName(EV_SOCK_ERROR), iPoolId(id), sSocketError(std::move(err)) { } + ex_event(std::string&& err, bool silent, size_t id) : iName(EV_SOCK_ERROR), iPoolId(id), oSocketError(std::move(err), silent) { } ex_event(job_result dat, size_t id) : iName(EV_MINER_HAVE_RESULT), iPoolId(id), oJobResult(dat) {} ex_event(pool_job dat, size_t id) : iName(EV_POOL_HAVE_JOB), iPoolId(id), oPoolJob(dat) {} ex_event(ex_event_name ev, size_t id = 0) : iName(ev), iPoolId(id) {} @@ -85,7 +107,7 @@ struct ex_event switch(iName) { case EV_SOCK_ERROR: - new (&sSocketError) std::string(std::move(from.sSocketError)); + new (&oSocketError) sock_err(std::move(from.oSocketError)); break; case EV_MINER_HAVE_RESULT: oJobResult = from.oJobResult; @@ -103,7 +125,7 @@ struct ex_event assert(this != &from); if(iName == EV_SOCK_ERROR) - sSocketError.~basic_string(); + oSocketError.~sock_err(); iName = from.iName; iPoolId = from.iPoolId; @@ -111,8 +133,8 @@ struct ex_event switch(iName) { case EV_SOCK_ERROR: - new (&sSocketError) std::string(); - sSocketError = std::move(from.sSocketError); + new (&oSocketError) sock_err(); + oSocketError = std::move(from.oSocketError); break; case EV_MINER_HAVE_RESULT: oJobResult = from.oJobResult; @@ -130,6 +152,14 @@ struct ex_event ~ex_event() { if(iName == EV_SOCK_ERROR) - sSocketError.~basic_string(); + oSocketError.~sock_err(); } }; + +#include +//Get steady_clock timestamp - misc helper function +inline size_t get_timestamp() +{ + using namespace std::chrono; + return time_point_cast(steady_clock::now()).time_since_epoch().count(); +}; diff --git a/xmrstak/net/socket.cpp b/xmrstak/net/socket.cpp index b93376e..7079205 100644 --- a/xmrstak/net/socket.cpp +++ b/xmrstak/net/socket.cpp @@ -185,7 +185,15 @@ void tls_socket::print_error() char *buf = nullptr; size_t len = BIO_get_mem_data(err_bio, &buf); - pCallback->set_socket_error(buf, len); + if(buf == nullptr) + { + if(jconf::inst()->TlsSecureAlgos()) + pCallback->set_socket_error("Unknown TLS error. Secure TLS maybe unspported, try setting tls_secure_algo to false."); + else + pCallback->set_socket_error("Unknown TLS error."); + } + else + pCallback->set_socket_error(buf, len); BIO_free(err_bio); } @@ -290,41 +298,42 @@ bool tls_socket::connect() return false; } - if(pCallback->pool_id != executor::dev_pool_id) + //Base64 encode digest + BIO *bmem, *b64; + b64 = BIO_new(BIO_f_base64()); + bmem = BIO_new(BIO_s_mem()); + + BIO_puts(bmem, "SHA256:"); + b64 = BIO_push(b64, bmem); + BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); + BIO_write(b64, md, dlen); + BIO_flush(b64); + + const char* conf_md = pCallback->get_tls_fp(); + char *b64_md = nullptr; + size_t b64_len = BIO_get_mem_data(bmem, &b64_md); + + if(strlen(conf_md) == 0) { - //Base64 encode digest - BIO *bmem, *b64; - b64 = BIO_new(BIO_f_base64()); - bmem = BIO_new(BIO_s_mem()); - - BIO_puts(bmem, "SHA256:"); - b64 = BIO_push(b64, bmem); - BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); - BIO_write(b64, md, dlen); - BIO_flush(b64); - - const char* conf_md = jconf::inst()->GetTlsFingerprint(); - char *b64_md = nullptr; - size_t b64_len = BIO_get_mem_data(bmem, &b64_md); - - if(strlen(conf_md) == 0) - { - printer::inst()->print_msg(L1, "Server fingerprint: %.*s", (int)b64_len, b64_md); - } - else if(strncmp(b64_md, conf_md, b64_len) != 0) + if(!pCallback->is_dev_pool()) + printer::inst()->print_msg(L1, "TLS fingerprint [%s] %.*s", pCallback->get_pool_addr(), (int)b64_len, b64_md); + } + else if(strncmp(b64_md, conf_md, b64_len) != 0) + { + if(!pCallback->is_dev_pool()) { - printer::inst()->print_msg(L0, "FINGERPRINT FAILED CHECK: %.*s was given, %s was configured", - (int)b64_len, b64_md, conf_md); - - pCallback->set_socket_error("FINGERPRINT FAILED CHECK"); - BIO_free_all(b64); - X509_free(cert); - return false; + printer::inst()->print_msg(L0, "FINGERPRINT FAILED CHECK [%s] %.*s was given, %s was configured", + pCallback->get_pool_addr(), (int)b64_len, b64_md, conf_md); } + pCallback->set_socket_error("FINGERPRINT FAILED CHECK"); BIO_free_all(b64); + X509_free(cert); + return false; } + BIO_free_all(b64); + X509_free(cert); return true; } -- cgit v1.1