Merge pull request #115 from fireice-uk/topic-net-ext

Network extensions

14 files changed, 251 insertions, 31 deletions

diff --git a/xmrstak/backend/amd/minethd.cpp b/xmrstak/backend/amd/minethd.cpp
index 94fc088..de0b6e8 100644
--- a/xmrstak/backend/amd/minethd.cpp
+++ b/xmrstak/backend/amd/minethd.cpp
@@ -241,7 +241,7 @@ void minethd::work_main()
 
 				hash_fun(bWorkBlob, oWork.iWorkSize, bResult, cpu_ctx);
 				if ( (*((uint64_t*)(bResult + 24))) < oWork.iTarget)
-					executor::inst()->push_event(ex_event(job_result(oWork.sJobID, results[i], bResult), oWork.iPoolId));
+					executor::inst()->push_event(ex_event(job_result(oWork.sJobID, results[i], bResult, iThreadNo), oWork.iPoolId));
 				else
 					executor::inst()->push_event(ex_event("AMD Invalid Result", oWork.iPoolId));
 			}
diff --git a/xmrstak/backend/cpu/minethd.cpp b/xmrstak/backend/cpu/minethd.cpp
index 8183adf..03071c4 100644
--- a/xmrstak/backend/cpu/minethd.cpp
+++ b/xmrstak/backend/cpu/minethd.cpp
@@ -358,7 +358,8 @@ void minethd::work_main()
 	piHashVal = (uint64_t*)(result.bResult + 24);
 	piNonce = (uint32_t*)(oWork.bWorkBlob + 39);
 	globalStates::inst().inst().iConsumeCnt++;
-
+	result.iThreadId = iThreadNo;
+	
 	while (bQuit == 0)
 	{
 		if (oWork.bStall)
@@ -542,17 +543,16 @@ void minethd::double_work_main()
 				globalStates::inst().calc_start_nonce(iNonce, oWork.bNiceHash, nonce_chunk);
 			}
 
-
 			*piNonce0 = ++iNonce;
 			*piNonce1 = ++iNonce;
 
 			hash_fun(bDoubleWorkBlob, oWork.iWorkSize, bDoubleHashOut, ctx0, ctx1);
 
 			if (*piHashVal0 < oWork.iTarget)
-				executor::inst()->push_event(ex_event(job_result(oWork.sJobID, iNonce-1, bDoubleHashOut), oWork.iPoolId));
+				executor::inst()->push_event(ex_event(job_result(oWork.sJobID, iNonce-1, bDoubleHashOut, iThreadNo), oWork.iPoolId));
 
 			if (*piHashVal1 < oWork.iTarget)
-				executor::inst()->push_event(ex_event(job_result(oWork.sJobID, iNonce, bDoubleHashOut + 32), oWork.iPoolId));
+				executor::inst()->push_event(ex_event(job_result(oWork.sJobID, iNonce, bDoubleHashOut + 32, iThreadNo), oWork.iPoolId));
 
 			std::this_thread::yield();
 		}
diff --git a/xmrstak/backend/iBackend.hpp b/xmrstak/backend/iBackend.hpp
index dbfbc99..3d2115a 100644
--- a/xmrstak/backend/iBackend.hpp
+++ b/xmrstak/backend/iBackend.hpp
@@ -8,22 +8,33 @@
 #include <vector>
 #include <string>
 
+template <typename T, std::size_t N>
+constexpr std::size_t countof(T const (&)[N]) noexcept
+{
+	return N;
+}
+
 namespace xmrstak
 {
 	struct iBackend
 	{
 
-		enum BackendType : uint32_t { UNKNOWN = 0, CPU = 1u, AMD = 2u, NVIDIA = 3u };
+		enum BackendType : uint32_t { UNKNOWN = 0u, CPU = 1u, AMD = 2u, NVIDIA = 3u };
 		
-		static std::string getName(const BackendType type)
+		static const char* getName(const BackendType type)
 		{
-			std::vector<std::string> backendNames = {
-				"UNKNOWN",
-				"CPU",
-				"AMD",
-				"NVIDIA"
+			const char* backendNames[] = {
+				"unknown",
+				"cpu",
+				"amd",
+				"nvidia"
 			};
-			return backendNames[static_cast<uint32_t>(type)];
+
+			uint32_t i = static_cast<uint32_t>(type);
+			if(i >= countof(backendNames))
+				i = 0;
+
+			return backendNames[i];
 		}
 
 		std::atomic<uint64_t> iHashCount;
diff --git a/xmrstak/backend/nvidia/minethd.cpp b/xmrstak/backend/nvidia/minethd.cpp
index 4d9efd2..9dbd83e 100644
--- a/xmrstak/backend/nvidia/minethd.cpp
+++ b/xmrstak/backend/nvidia/minethd.cpp
@@ -283,7 +283,7 @@ void minethd::work_main()
 
 				hash_fun(bWorkBlob, oWork.iWorkSize, bResult, cpu_ctx);
 				if ( (*((uint64_t*)(bResult + 24))) < oWork.iTarget)
-					executor::inst()->push_event(ex_event(job_result(oWork.sJobID, foundNonce[i], bResult), oWork.iPoolId));
+					executor::inst()->push_event(ex_event(job_result(oWork.sJobID, foundNonce[i], bResult, iThreadNo), oWork.iPoolId));
 				else
 					executor::inst()->push_event(ex_event("NVIDIA Invalid Result", oWork.iPoolId));
 			}
diff --git a/xmrstak/config.tpl b/xmrstak/config.tpl
index c3ea061..ae97190 100644
--- a/xmrstak/config.tpl
+++ b/xmrstak/config.tpl
@@ -51,8 +51,11 @@ POOLCONF],
  *                 2 - All of level 1, and new job (block) event if the difficulty is different from the last job
  *                 3 - All of level 1, and new job (block) event in all cases, result submission event.
  *                 4 - All of level 3, and automatic hashrate report printing
+ *
+ * print_motd    - Display messages from your pool operator in the hashrate result.
  */
 "verbose_level" : 3,
+"print_motd" : true,
 
 /*
  * Automatic hashrate report
diff --git a/xmrstak/http/webdesign.cpp b/xmrstak/http/webdesign.cpp
index 3c33e1f..963c080 100644
--- a/xmrstak/http/webdesign.cpp
+++ b/xmrstak/http/webdesign.cpp
@@ -1,6 +1,6 @@
 #include <stdlib.h>
 
-extern const char sHtmlCssEtag [] = "00000008";
+extern const char sHtmlCssEtag [] = "00000009";
 extern const char sHtmlCssFile [] =
 	"body {"
 		"font-family: Tahoma, Arial, sans-serif;"
@@ -92,6 +92,23 @@ extern const char sHtmlCssFile [] =
 	".flex-item {"
 		"width: 33%;"
 		"margin: 3px;"
+	"}"
+
+	".motd-box {"
+		"background-color: #ccc;"
+		"padding: 0px 10px 5px 10px;"
+		"margin-bottom: 10px;"
+	"}"
+
+	".motd-head {"
+		"border-bottom: 1px solid #000;"
+		"margin-bottom: 0.5em;"
+		"padding: 0.5em 0em;"
+		"font-weight: bold;"
+	"}"
+	
+	".motd-body {"
+		"overflow: hidden;"
 	"}";
 
 size_t sHtmlCssSize = sizeof(sHtmlCssFile) - 1;
@@ -130,6 +147,10 @@ extern const char sHtmlCommonHeader [] =
 	"</div>"
 	"<h4>%s</h4>";
 
+extern const char sHtmlMotdBoxStart[] = "<div class='motd-box'>";
+extern const char sHtmlMotdEntry[] = "<div class='motd-head'>Message from %s</div><div class='motd-body'>%s</div>";
+extern const char sHtmlMotdBoxEnd[] = "</div>";
+
 extern const char sHtmlHashrateBodyHigh [] =
 	"<div class=data>"
 	"<table>"
diff --git a/xmrstak/http/webdesign.hpp b/xmrstak/http/webdesign.hpp
index 122b5fb..48adfea 100644
--- a/xmrstak/http/webdesign.hpp
+++ b/xmrstak/http/webdesign.hpp
@@ -12,6 +12,10 @@ extern const char sHttpAuthOpaque[];
 
 extern const char sHtmlCommonHeader[];
 
+extern const char sHtmlMotdBoxStart[];
+extern const char sHtmlMotdEntry[];
+extern const char sHtmlMotdBoxEnd[];
+
 extern const char sHtmlHashrateBodyHigh[];
 extern const char sHtmlHashrateTableRow[];
 extern const char sHtmlHashrateBodyLow[];
diff --git a/xmrstak/jconf.cpp b/xmrstak/jconf.cpp
index 6d0f8ae..a617f96 100644
--- a/xmrstak/jconf.cpp
+++ b/xmrstak/jconf.cpp
@@ -51,7 +51,7 @@ using namespace rapidjson;
  * This enum needs to match index in oConfigValues, otherwise we will get a runtime error
  */
 enum configEnum {
-	aPoolList, bTlsSecureAlgo, sCurrency, iCallTimeout, iNetRetry, iGiveUpLimit, iVerboseLevel, iAutohashTime, 
+	aPoolList, bTlsSecureAlgo, sCurrency, iCallTimeout, iNetRetry, iGiveUpLimit, iVerboseLevel, bPrintMotd, iAutohashTime, 
 	bFlushStdout, bDaemonMode, sOutputFile, iHttpdPort, sHttpLogin, sHttpPass, bPreferIpv4, bAesOverride, sUseSlowMem 
 };
 
@@ -71,6 +71,7 @@ configVal oConfigValues[] = {
 	{ iNetRetry, "retry_time", kNumberType },
 	{ iGiveUpLimit, "giveup_limit", kNumberType },
 	{ iVerboseLevel, "verbose_level", kNumberType },
+	{ bPrintMotd, "print_motd", kTrueType },
 	{ iAutohashTime, "h_print_time", kNumberType },
 	{ bFlushStdout, "flush_stdout", kTrueType},
 	{ bDaemonMode, "daemon_mode", kTrueType },
@@ -193,7 +194,7 @@ const std::string jconf::GetCurrency()
 
 bool jconf::IsCurrencyMonero()
 {
-	if(xmrstak::strcmp_i(::jconf::inst()->GetCurrency(), "monero"))
+	if(xmrstak::strcmp_i(GetCurrency(), "monero"))
 	{
 		return true;
 	}
@@ -228,6 +229,11 @@ uint64_t jconf::GetVerboseLevel()
 	return prv->configValues[iVerboseLevel]->GetUint64();
 }
 
+bool jconf::PrintMotd()
+{
+	return prv->configValues[bPrintMotd]->GetBool();
+}
+
 uint64_t jconf::GetAutohashTime()
 {
 	return prv->configValues[iAutohashTime]->GetUint64();
diff --git a/xmrstak/jconf.hpp b/xmrstak/jconf.hpp
index 1bd4d47..131263e 100644
--- a/xmrstak/jconf.hpp
+++ b/xmrstak/jconf.hpp
@@ -51,6 +51,7 @@ public:
 	bool IsCurrencyMonero();
 
 	uint64_t GetVerboseLevel();
+	bool PrintMotd();
 	uint64_t GetAutohashTime();
 
 	const char* GetOutputFile();
diff --git a/xmrstak/misc/executor.cpp b/xmrstak/misc/executor.cpp
index 4a3a77b..43e3d6b 100644
--- a/xmrstak/misc/executor.cpp
+++ b/xmrstak/misc/executor.cpp
@@ -400,12 +400,13 @@ void executor::on_pool_have_job(size_t pool_id, pool_job& oPoolJob)
 void executor::on_miner_result(size_t pool_id, job_result& oResult)
 {
 	jpsock* pool = pick_pool_by_id(pool_id);
+	bool is_monero = jconf::inst()->IsCurrencyMonero();
 
 	if(pool->is_dev_pool())
 	{
 		//Ignore errors silently
 		if(pool->is_running() && pool->is_logged_in())
-			pool->cmd_submit(oResult.sJobID, oResult.iNonce, oResult.bResult);
+			pool->cmd_submit(oResult.sJobID, oResult.iNonce, oResult.bResult, pvThreads->at(oResult.iThreadId), is_monero);
 
 		return;
 	}
@@ -418,7 +419,7 @@ void executor::on_miner_result(size_t pool_id, job_result& oResult)
 
 	using namespace std::chrono;
 	size_t t_start = time_point_cast<milliseconds>(high_resolution_clock::now()).time_since_epoch().count();
-	bool bResult = pool->cmd_submit(oResult.sJobID, oResult.iNonce, oResult.bResult);
+	bool bResult = pool->cmd_submit(oResult.sJobID, oResult.iNonce, oResult.bResult, pvThreads->at(oResult.iThreadId), is_monero);
 	size_t t_len = time_point_cast<milliseconds>(high_resolution_clock::now()).time_since_epoch().count() - t_start;
 
 	if(t_len > 0xFFFF)
@@ -630,8 +631,75 @@ inline const char* hps_format(double h, char* buf, size_t l)
 		return " (na)";
 }
 
+bool executor::motd_filter_console(std::string& motd)
+{
+	if(motd.size() > motd_max_length)
+		return false;
+
+	motd.erase(std::remove_if(motd.begin(), motd.end(), [](int chr)->bool { return !((chr >= 0x20 && chr <= 0x7e) || chr == '\n');}), motd.end());
+	return motd.size() > 0;
+}
+
+bool executor::motd_filter_web(std::string& motd)
+{
+	if(!motd_filter_console(motd))
+		return false;
+
+	std::string tmp;
+	tmp.reserve(motd.size() + 128);
+
+	for(size_t i=0; i < motd.size(); i++)
+	{
+		char c = motd[i];
+		switch(c)
+		{
+		case '&':
+			tmp.append("&amp;");
+			break;
+		case '"':
+			tmp.append("&quot;");
+			break;
+		case '\'':
+			tmp.append("&#039");
+			break;
+		case '<':
+			tmp.append("&lt;");
+			break;
+		case '>':
+			tmp.append("&gt;");
+			break;
+		case '\n':
+			tmp.append("<br>");
+			break;
+		default:
+			tmp.append(1, c);
+			break;
+		}
+	}
+
+	motd = std::move(tmp);
+	return true;
+}
+
 void executor::hashrate_report(std::string& out)
 {
+	out.reserve(2048 + pvThreads->size() * 64);
+
+	if(jconf::inst()->PrintMotd())
+	{
+		std::string motd;
+		for(jpsock& pool : pools)
+		{
+			motd.empty();
+			if(pool.get_pool_motd(motd) && motd_filter_console(motd))
+			{
+				out.append("Message from ").append(pool.get_pool_addr()).append(":\n");
+				out.append(motd).append("\n");
+				out.append("-----------------------------------------------------\n");
+			}
+		}
+	}
+
 	char num[32];
 	double fTotal[3] = { 0.0, 0.0, 0.0};
 
@@ -648,11 +716,12 @@ void executor::hashrate_report(std::string& out)
 		size_t nthd = backEnds.size();
 		if(nthd != 0)
 		{
-			out.reserve(256 + nthd * 64);
-
 			size_t i;
 			auto bType = static_cast<xmrstak::iBackend::BackendType>(b);
-			out.append("HASHRATE REPORT - ").append(xmrstak::iBackend::getName(bType)).append("\n");
+			std::string name(xmrstak::iBackend::getName(bType));
+			std::transform(name.begin(), name.end(), name.begin(), ::toupper);
+			
+			out.append("HASHRATE REPORT - ").append(name).append("\n");
 			out.append("| ID | 10s |  60s |  15m |");
 			if(nthd != 1)
 				out.append(" ID | 10s |  60s |  15m |\n");
@@ -864,6 +933,30 @@ void executor::http_hashrate_report(std::string& out)
 	snprintf(buffer, sizeof(buffer), sHtmlCommonHeader, "Hashrate Report", ver_html, "Hashrate Report");
 	out.append(buffer);
 
+	bool have_motd = false;
+	if(jconf::inst()->PrintMotd())
+	{
+		std::string motd;
+		for(jpsock& pool : pools)
+		{
+			motd.empty();
+			if(pool.get_pool_motd(motd) && motd_filter_web(motd))
+			{
+				if(!have_motd)
+				{
+					out.append(sHtmlMotdBoxStart);
+					have_motd = true;
+				}
+				
+				snprintf(buffer, sizeof(buffer), sHtmlMotdEntry, pool.get_pool_addr(), motd.c_str());
+				out.append(buffer);
+			}
+		}
+	}
+
+	if(have_motd)
+		out.append(sHtmlMotdBoxEnd);
+
 	snprintf(buffer, sizeof(buffer), sHtmlHashrateBodyHigh, (unsigned int)nthd + 3);
 	out.append(buffer);
 
diff --git a/xmrstak/misc/executor.hpp b/xmrstak/misc/executor.hpp
index 9ff0323..c90e864 100644
--- a/xmrstak/misc/executor.hpp
+++ b/xmrstak/misc/executor.hpp
@@ -94,6 +94,10 @@ private:
 	void ex_clock_thd();
 	void pool_connect(jpsock* pool);
 
+	constexpr static size_t motd_max_length = 512;
+	bool motd_filter_console(std::string& motd);
+	bool motd_filter_web(std::string& motd);
+	
 	void hashrate_report(std::string& out);
 	void result_report(std::string& out);
 	void connection_report(std::string& out);
diff --git a/xmrstak/net/jpsock.cpp b/xmrstak/net/jpsock.cpp
index cb586d2..5769448 100644
--- a/xmrstak/net/jpsock.cpp
+++ b/xmrstak/net/jpsock.cpp
@@ -23,6 +23,7 @@
 
 #include <stdarg.h>
 #include <assert.h>
+#include <algorithm>
 
 #include "jpsock.hpp"
 #include "socks.hpp"
@@ -33,9 +34,6 @@
 #include "xmrstak/misc/jext.hpp"
 #include "xmrstak/version.hpp"
 
-
-#define AGENTID_STR XMR_STAK_NAME "/" XMR_STAK_VERSION
-
 using namespace rapidjson;
 
 struct jpsock::call_rsp
@@ -366,10 +364,11 @@ bool jpsock::process_pool_job(const opq_json_val* params)
 	if (!params->val->IsObject())
 		return set_socket_error("PARSE error: Job error 1");
 
-	const Value * blob, *jobid, *target;
+	const Value *blob, *jobid, *target, *motd;
 	jobid = GetObjectMember(*params->val, "job_id");
 	blob = GetObjectMember(*params->val, "blob");
 	target = GetObjectMember(*params->val, "target");
+	motd = GetObjectMember(*params->val, "motd");
 
 	if (jobid == nullptr || blob == nullptr || target == nullptr ||
 		!jobid->IsString() || !blob->IsString() || !target->IsString())
@@ -415,6 +414,19 @@ bool jpsock::process_pool_job(const opq_json_val* params)
 	else
 		return set_socket_error("PARSE error: Job error 5");
 
+	if(motd != nullptr && motd->IsString() && (motd->GetStringLength() & 0x01) == 0)
+	{
+		std::unique_lock<std::mutex>(motd_mutex);
+		if(motd->GetStringLength() > 0)
+		{
+			pool_motd.resize(motd->GetStringLength()/2 + 1);
+			if(!hex2bin(motd->GetString(), motd->GetStringLength(), (unsigned char*)&pool_motd.front()))
+				pool_motd.clear();
+		}
+		else
+			pool_motd.clear();
+	}
+
 	iJobDiff = t64_to_diff(oPoolJob.iTarget);
 
 	executor::inst()->push_event(ex_event(oPoolJob, pool_id));
@@ -426,6 +438,7 @@ bool jpsock::process_pool_job(const opq_json_val* params)
 
 bool jpsock::connect(std::string& sConnectError)
 {
+	ext_algo = ext_backend = ext_hashcount = ext_motd = false;
 	bHaveSocketError = false;
 	sSocketError.clear();
 	iJobDiff = 0;
@@ -527,6 +540,7 @@ bool jpsock::cmd_login()
 
 	const Value* id = GetObjectMember(*oResult.val, "id");
 	const Value* job = GetObjectMember(*oResult.val, "job");
+	const Value* ext = GetObjectMember(*oResult.val, "extensions");
 
 	if (id == nullptr || job == nullptr || !id->IsString())
 	{
@@ -545,6 +559,29 @@ bool jpsock::cmd_login()
 	memset(sMinerId, 0, sizeof(sMinerId));
 	memcpy(sMinerId, id->GetString(), id->GetStringLength());
 
+	if(ext != nullptr && ext->IsArray())
+	{
+		for(size_t i=0; i < ext->Size(); i++)
+		{
+			const Value& jextname = ext->GetArray()[i];
+			
+			if(!jextname.IsString())
+				continue;
+
+			std::string tmp(jextname.GetString());
+			std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
+
+			if(tmp == "algo")
+				ext_algo = true;
+			else if(tmp == "backend")
+				ext_backend = true;
+			else if(tmp == "hashcount")
+				ext_hashcount = true;
+			else if(tmp == "motd")
+				ext_motd = true;
+		}
+	}
+
 	opq_json_val v(job);
 	if(!process_pool_job(&v))
 	{
@@ -558,20 +595,33 @@ bool jpsock::cmd_login()
 	return true;
 }
 
-bool jpsock::cmd_submit(const char* sJobId, uint32_t iNonce, const uint8_t* bResult)
+bool jpsock::cmd_submit(const char* sJobId, uint32_t iNonce, const uint8_t* bResult, xmrstak::iBackend* bend, bool algo_full_cn)
 {
 	char cmd_buffer[1024];
 	char sNonce[9];
 	char sResult[65];
+	/*Extensions*/
+	char sAlgo[64] = {0};
+	char sBackend[64] = {0};
+	char sHashcount[64] = {0};
 
+	if(ext_backend)
+		snprintf(sBackend, sizeof(sBackend), ",\"backend\":\"%s\"", xmrstak::iBackend::getName(bend->backendType));
+	
+	if(ext_hashcount)
+		snprintf(sHashcount, sizeof(sHashcount), ",\"hashcount\":%llu", int_port(bend->iHashCount.load(std::memory_order_relaxed)));
+
+	if(ext_algo)
+		snprintf(sAlgo, sizeof(sAlgo), ",\"algo\":\"%s\"", algo_full_cn ? "cryptonight" : "cryptonight-lite");
+	
 	bin2hex((unsigned char*)&iNonce, 4, sNonce);
 	sNonce[8] = '\0';
 
 	bin2hex(bResult, 32, sResult);
 	sResult[64] = '\0';
 
-	snprintf(cmd_buffer, sizeof(cmd_buffer), "{\"method\":\"submit\",\"params\":{\"id\":\"%s\",\"job_id\":\"%s\",\"nonce\":\"%s\",\"result\":\"%s\"},\"id\":1}\n",
-		sMinerId, sJobId, sNonce, sResult);
+	snprintf(cmd_buffer, sizeof(cmd_buffer), "{\"method\":\"submit\",\"params\":{\"id\":\"%s\",\"job_id\":\"%s\",\"nonce\":\"%s\",\"result\":\"%s\"%s%s%s},\"id\":1}\n",
+		sMinerId, sJobId, sNonce, sResult, sBackend, sHashcount, sAlgo);
 
 	opq_json_val oResult(nullptr);
 	return cmd_ret_wait(cmd_buffer, oResult);
@@ -594,6 +644,21 @@ bool jpsock::get_current_job(pool_job& job)
 	return true;
 }
 
+bool jpsock::get_pool_motd(std::string& strin)
+{
+	if(!ext_motd) 
+		return false;
+	
+	std::unique_lock<std::mutex>(motd_mutex);
+	if(pool_motd.size() > 0)
+	{
+		strin.assign(pool_motd);
+		return true;
+	}
+
+	return false;
+}
+
 inline unsigned char hf_hex2bin(char c, bool &err)
 {
 	if (c >= '0' && c <= '9')
diff --git a/xmrstak/net/jpsock.hpp b/xmrstak/net/jpsock.hpp
index db8cd0e..9d276b7 100644
--- a/xmrstak/net/jpsock.hpp
+++ b/xmrstak/net/jpsock.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "xmrstak/backend/iBackend.hpp"
 #include "msgstruct.hpp"
 
 #include <mutex>
@@ -33,7 +34,7 @@ public:
 	void disconnect(bool quiet = false);
 
 	bool cmd_login();
-	bool cmd_submit(const char* sJobId, uint32_t iNonce, const uint8_t* bResult);
+	bool cmd_submit(const char* sJobId, uint32_t iNonce, const uint8_t* bResult, xmrstak::iBackend* bend, bool algo_full_cn);
 
 	static bool hex2bin(const char* in, unsigned int len, unsigned char* out);
 	static void bin2hex(const unsigned char* in, unsigned int len, char* out);
@@ -58,6 +59,8 @@ public:
 	inline const char* get_tls_fp() { return tls_fp.c_str(); }
 	inline bool is_nicehash() { return nicehash; }
 
+	bool get_pool_motd(std::string& strin);
+
 	std::string&& get_call_error();
 	bool have_sock_error() { return bHaveSocketError; }
 
@@ -87,6 +90,14 @@ private:
 	bool pool;
 	bool nicehash;
 
+	bool ext_algo = false;
+	bool ext_backend = false;
+	bool ext_hashcount = false;
+	bool ext_motd = false;
+
+	std::string pool_motd;
+	std::mutex motd_mutex;
+
 	size_t connect_time = 0;
 	std::atomic<size_t> connect_attempts;
 	std::atomic<size_t> disconnect_time;
diff --git a/xmrstak/net/msgstruct.hpp b/xmrstak/net/msgstruct.hpp
index 4d8d845..9065fe3 100644
--- a/xmrstak/net/msgstruct.hpp
+++ b/xmrstak/net/msgstruct.hpp
@@ -30,9 +30,10 @@ struct job_result
 	uint8_t		bResult[32];
 	char		sJobID[64];
 	uint32_t	iNonce;
+	uint32_t	iThreadId;
 
 	job_result() {}
-	job_result(const char* sJobID, uint32_t iNonce, const uint8_t* bResult) : iNonce(iNonce)
+	job_result(const char* sJobID, uint32_t iNonce, const uint8_t* bResult, uint32_t iThreadId) : iNonce(iNonce), iThreadId(iThreadId)
 	{
 		memcpy(this->sJobID, sJobID, sizeof(job_result::sJobID));
 		memcpy(this->bResult, bResult, sizeof(job_result::bResult));