powerdlz23 1.1.6 → 1.1.8

package/pto/yaamp/stratum/client_core.cpp

@@ -0,0 +1,312 @@
+
+#include "stratum.h"
+
+static int g_extraonce1_counter = 0;
+
+void get_next_extraonce1(char *extraonce1)
+{
+	CommonLock(&g_nonce1_mutex);
+
+	g_extraonce1_counter++;
+	sprintf(extraonce1, "%08x", g_extraonce1_counter|0x81000000);
+
+	CommonUnlock(&g_nonce1_mutex);
+}
+
+void get_random_key(char *key)
+{
+	int i1 = rand();
+	int i2 = rand();
+	int i3 = rand();
+	int i4 = rand();
+	sprintf(key, "%08x%08x%08x%08x", i1, i2, i3, i4);
+}
+
+YAAMP_CLIENT *client_find_notify_id(const char *notify_id, bool reconnecting)
+{
+	g_list_client.Enter();
+	for(CLI li = g_list_client.first; li; li = li->next)
+	{
+		YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
+		if(client->reconnecting == reconnecting && !strcmp(client->notify_id, notify_id))
+		{
+			g_list_client.Leave();
+			return client;
+		}
+	}
+
+	g_list_client.Leave();
+	return NULL;
+}
+
+void client_sort()
+{
+	for(CLI li = g_list_client.first; li && li->next; li = li->next)
+	{
+		YAAMP_CLIENT *client1 = (YAAMP_CLIENT *)li->data;
+		YAAMP_CLIENT *client2 = (YAAMP_CLIENT *)li->next->data;
+
+//		if(client2->difficulty_actual > client1->difficulty_actual)
+		if(client2->speed > client1->speed*1.5)
+		{
+			g_list_client.Swap(li, li->next);
+			client_sort();
+
+			return;
+		}
+	}
+}
+
+int client_send_error(YAAMP_CLIENT *client, int error, const char *string)
+{
+	char buffer3[1024];
+
+	if(client->id_str)
+		sprintf(buffer3, "\"%s\"", client->id_str);
+	else
+		sprintf(buffer3, "%d", client->id_int);
+
+	return socket_send(client->sock, "{\"id\":%s,\"result\":false,\"error\":[%d,\"%s\",null]}\n", buffer3, error, string);
+}
+
+int client_send_result(YAAMP_CLIENT *client, const char *format, ...)
+{
+	char buffer[YAAMP_SMALLBUFSIZE];
+	va_list args;
+
+	va_start(args, format);
+	vsprintf(buffer, format, args);
+	va_end(args);
+
+	char buffer3[1024];
+
+	if(client->id_str)
+		sprintf(buffer3, "\"%s\"", client->id_str);
+	else
+		sprintf(buffer3, "%d", client->id_int);
+
+	return socket_send(client->sock, "{\"id\":%s,\"result\":%s,\"error\":null}\n", buffer3, buffer);
+}
+
+int client_call(YAAMP_CLIENT *client, const char *method, const char *format, ...)
+{
+	char buffer[YAAMP_SMALLBUFSIZE];
+	va_list args;
+
+	va_start(args, format);
+	vsprintf(buffer, format, args);
+	va_end(args);
+
+	return socket_send(client->sock, "{\"id\":null,\"method\":\"%s\",\"params\":%s}\n", method, buffer);
+}
+
+void client_block_ip(YAAMP_CLIENT *client, const char *reason)
+{
+	char buffer[1024];
+
+	sprintf(buffer, "iptables -A INPUT -s %s -j DROP", client->sock->ip);
+	int s = system(buffer);
+
+	stratumlog("%s %s blocked (%s)\n", client->sock->ip, client->username, reason);
+}
+
+bool client_reset_multialgo(YAAMP_CLIENT *client, bool first)
+{
+//	return false;
+	if(!client->algos_subscribed[0].algo) return false;
+//	debuglog("client_reset_multialgo\n");
+
+	YAAMP_CLIENT_ALGO *best = NULL;
+	YAAMP_CLIENT_ALGO *current = NULL;
+
+	for(int i=0; g_algos[i].name[0]; i++)
+	{
+		YAAMP_ALGO *algo = &g_algos[i];
+		for(int j=0; client->algos_subscribed[j].algo; j++)
+		{
+			YAAMP_CLIENT_ALGO *candidate = &client->algos_subscribed[j];
+			if(candidate->algo == algo)
+			{
+				if(!best || algo->profit*candidate->factor > best->algo->profit*best->factor)
+					best = candidate;
+			}
+
+			if(!current && candidate->algo == g_current_algo)
+				current = candidate;
+		}
+	}
+
+	if(!best || !current || best == current)
+	{
+		client->last_best = time(NULL);
+		return false;
+	}
+
+	if(!first)
+	{
+		int e = time(NULL) - client->last_best;
+		double d = best->algo->profit*best->factor - current->algo->profit*current->factor;
+		double p = d/best->algo->profit/best->factor;
+
+//		debuglog("current %s %f\n", current->algo->name, current->algo->profit*current->factor);
+//		debuglog("best    %s %f\n", best->algo->name, best->algo->profit*best->factor);
+//		debuglog(" %d * %f = %f --- percent %f %f\n", e, d, e*d, p, e*p);
+
+		if(p < 0.02) return false;
+		if(e*p < 100) return false;
+	}
+
+	shutdown(client->sock->sock, SHUT_RDWR);
+	return true;
+}
+
+bool client_initialize_multialgo(YAAMP_CLIENT *client)
+{
+	char *p = strstr(client->password, "p=");
+	if(p)
+	{
+		double profit = atof(p+2);
+		if(profit > g_current_algo->profit)
+			return true;
+	}
+
+	char tmp[1024];
+	memset(tmp, 0, 1024);
+	strncpy(tmp, client->password, 1023);
+
+	p = tmp;
+	while(p)
+	{
+		double value = 0;
+
+		char *p1 = strchr(p, ',');
+		if(p1) *p1 = 0;
+
+		char *p2 = strchr(p, '=');
+		if(p2)
+		{
+			*p2 = 0;
+			value = atof(p2+1);
+		}
+
+		for(int i=0; g_algos[i].name[0]; i++)
+		{
+			YAAMP_ALGO *algo = &g_algos[i];
+			if(!strcmp(algo->name, p))
+			{
+				int i=0;
+				for(; i<YAAMP_MAXALGOS-1 && client->algos_subscribed[i].algo; i++);
+
+				client->algos_subscribed[i].algo = algo;
+				client->algos_subscribed[i].factor = value? value: algo->factor;
+			}
+		}
+
+		p = p1? p1+1: p1;
+	}
+
+	bool reset = client_reset_multialgo(client, true);
+	return reset;
+}
+
+void client_add_job_history(YAAMP_CLIENT *client, int jobid)
+{
+	if(!jobid)
+	{
+		debuglog("trying to add jobid 0\n");
+		return;
+	}
+
+	bool b = client_find_job_history(client, jobid, 0);
+	if(b)
+	{
+//		debuglog("ERROR history already added job %x\n", jobid);
+		return;
+	}
+
+	for(int i=YAAMP_JOB_MAXHISTORY-1; i>0; i--)
+		client->job_history[i] = client->job_history[i-1];
+
+	client->job_history[0] = jobid;
+}
+
+bool client_find_job_history(YAAMP_CLIENT *client, int jobid, int startat)
+{
+	for(int i=startat; i<YAAMP_JOB_MAXHISTORY; i++)
+	{
+		if(client->job_history[i] == jobid)
+		{
+//			if(!startat)
+//				debuglog("job %x already sent, index %d\n", jobid, i);
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+int hostname_to_ip(const char *hostname , char* ip)
+{
+    struct hostent *he;
+    struct in_addr **addr_list;
+    int i;
+
+    if(hostname[0]>='0' && hostname[0]<='9')
+    {
+    	strcpy(ip, hostname);
+    	return 0;
+    }
+
+    if ( (he = gethostbyname( hostname ) ) == NULL)
+    {
+        // get the host info
+        herror("gethostbyname");
+        return 1;
+    }
+
+    addr_list = (struct in_addr **) he->h_addr_list;
+
+    for(i = 0; addr_list[i] != NULL; i++)
+    {
+        //Return the first one;
+        strcpy(ip, inet_ntoa(*addr_list[i]));
+        return 0;
+    }
+
+    return 1;
+}
+
+bool client_find_my_ip(const char *name)
+{
+//	return false;
+	char ip[1024] = "";
+
+	hostname_to_ip(name, ip);
+	if(!ip[0]) return false;
+
+	char host[NI_MAXHOST];
+	for(struct ifaddrs *ifa = g_ifaddr; ifa != NULL; ifa = ifa->ifa_next)
+	{
+		if(ifa->ifa_addr == NULL) continue;
+		host[0] = 0;
+
+		getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+		if(!host[0]) continue;
+
+		if(!strcmp(host, ip))
+		{
+			debuglog("found my ip %s\n", ip);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+
+
+
+

package/pto/yaamp/stratum/client_difficulty.cpp

@@ -0,0 +1,105 @@
+
+#include "stratum.h"
+
+double client_normalize_difficulty(double difficulty)
+{
+	if(difficulty <= 0.001) difficulty = 0.001;
+	else if(difficulty < 1) difficulty = floor(difficulty*1000/2)/1000*2;
+	else if(difficulty > 1) difficulty = floor(difficulty/2)*2;
+
+	return difficulty;
+}
+
+void client_record_difficulty(YAAMP_CLIENT *client)
+{
+	if(client->difficulty_remote)
+	{
+		client->last_submit_time = current_timestamp();
+		return;
+	}
+
+	int e = current_timestamp() - client->last_submit_time;
+	if(e < 500) e = 500;
+	int p = 5;
+
+	client->shares_per_minute = (client->shares_per_minute * (100 - p) + 60*1000*p/e) / 100;
+	client->last_submit_time = current_timestamp();
+
+//	debuglog("client->shares_per_minute %f\n", client->shares_per_minute);
+}
+
+void client_change_difficulty(YAAMP_CLIENT *client, double difficulty)
+{
+	if(difficulty <= 0) return;
+
+	difficulty = client_normalize_difficulty(difficulty);
+	if(difficulty <= 0) return;
+
+//	debuglog("change diff to %f %f\n", difficulty, client->difficulty_actual);
+	if(difficulty == client->difficulty_actual) return;
+
+	uint64_t user_target = diff_to_target(difficulty);
+	if(user_target >= YAAMP_MINDIFF && user_target <= YAAMP_MAXDIFF)
+	{
+		client->difficulty_actual = difficulty;
+		client_send_difficulty(client, difficulty);
+	}
+}
+
+void client_adjust_difficulty(YAAMP_CLIENT *client)
+{
+	if(client->difficulty_remote)
+	{
+		client_change_difficulty(client, client->difficulty_remote);
+		return;
+	}
+
+	if(client->shares_per_minute > 600)
+		client_change_difficulty(client, client->difficulty_actual*4);
+
+	else if(client->difficulty_fixed)
+		return;
+
+	else if(client->shares_per_minute > 25)
+		client_change_difficulty(client, client->difficulty_actual*2);
+
+	else if(client->shares_per_minute > 20)
+		client_change_difficulty(client, client->difficulty_actual*1.5);
+
+	else if(client->shares_per_minute <  5)
+		client_change_difficulty(client, client->difficulty_actual/2);
+}
+
+int client_send_difficulty(YAAMP_CLIENT *client, double difficulty)
+{
+//	debuglog("%s diff %f\n", client->sock->ip, difficulty);
+	client->shares_per_minute = YAAMP_SHAREPERSEC;
+
+	if(difficulty >= 1)
+		client_call(client, "mining.set_difficulty", "[%.0f]", difficulty);
+	else
+		client_call(client, "mining.set_difficulty", "[%.3f]", difficulty);
+}
+
+void client_initialize_difficulty(YAAMP_CLIENT *client)
+{
+	char *p = strstr(client->password, "d=");
+	if(!p) return;
+
+	double diff = client_normalize_difficulty(atof(p+2));
+	uint64_t user_target = diff_to_target(diff);
+
+//	debuglog("%016llx target\n", user_target);
+	if(user_target >= YAAMP_MINDIFF && user_target <= YAAMP_MAXDIFF)
+	{
+		client->difficulty_actual = diff;
+		client->difficulty_fixed = true;
+	}
+
+}
+
+
+
+
+
+

package/pto/yaamp/stratum/client_submit.cpp

@@ -0,0 +1,304 @@
+
+#include "stratum.h"
+
+//#define DONTSUBMIT
+
+void build_submit_values(YAAMP_JOB_VALUES *submitvalues, YAAMP_JOB_TEMPLATE *templ,
+	const char *nonce1, const char *nonce2, const char *ntime, const char *nonce)
+{
+	sprintf(submitvalues->coinbase, "%s%s%s%s", templ->coinb1, nonce1, nonce2, templ->coinb2);
+	int coinbase_len = strlen(submitvalues->coinbase);
+
+	unsigned char coinbase_bin[1024];
+	memset(coinbase_bin, 0, 1024);
+	binlify(coinbase_bin, submitvalues->coinbase);
+
+	char doublehash[128];
+	memset(doublehash, 0, 128);
+	sha256_double_hash_hex((char *)coinbase_bin, doublehash, coinbase_len/2);
+
+	string merkleroot = merkle_with_first(templ->txsteps, doublehash);
+	ser_string_be(merkleroot.c_str(), submitvalues->merkleroot_be, 8);
+
+	sprintf(submitvalues->header, "%s%s%s%s%s%s", templ->version, templ->prevhash_be, submitvalues->merkleroot_be,
+		ntime, templ->nbits, nonce);
+
+	ser_string_be(submitvalues->header, submitvalues->header_be, 20);
+	binlify(submitvalues->header_bin, submitvalues->header_be);
+
+//	printf("%s\n", submitvalues->header_be);
+	int header_len = strlen(submitvalues->header)/2;
+	g_current_algo->hash_function((char *)submitvalues->header_bin, (char *)submitvalues->hash_bin, header_len);
+
+	hexlify(submitvalues->hash_hex, submitvalues->hash_bin, 32);
+	string_be(submitvalues->hash_hex, submitvalues->hash_be);
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+
+void client_do_submit(YAAMP_CLIENT *client, YAAMP_JOB *job, YAAMP_JOB_VALUES *submitvalues, char *extranonce2, char *ntime, char *nonce)
+{
+	YAAMP_COIND *coind = job->coind;
+	YAAMP_JOB_TEMPLATE *templ = job->templ;
+
+	if(job->block_found) return;
+	if(job->deleted) return;
+
+	uint64_t hash_int = get_hash_difficulty(submitvalues->hash_bin);
+	uint64_t coin_target = decode_compact(templ->nbits);
+
+	int block_size = YAAMP_SMALLBUFSIZE;
+	vector<string>::const_iterator i;
+
+	for(i = templ->txdata.begin(); i != templ->txdata.end(); ++i)
+		block_size += strlen((*i).c_str());
+
+	char *block_hex = (char *)malloc(block_size);
+	if(!block_hex) return;
+
+	// do aux first
+	for(int i=0; i<templ->auxs_size; i++)
+	{
+		if(!templ->auxs[i]) continue;
+		YAAMP_COIND *coind_aux = templ->auxs[i]->coind;
+
+		unsigned char target_aux[1024];
+		binlify(target_aux, coind_aux->aux.target);
+
+		uint64_t coin_target_aux = get_hash_difficulty(target_aux);
+		if(hash_int <= coin_target_aux)
+		{
+			memset(block_hex, 0, block_size);
+
+			strcat(block_hex, submitvalues->coinbase);		// parent coinbase
+			strcat(block_hex, submitvalues->hash_be);		// parent hash
+
+			////////////////////////////////////////////////// parent merkle steps
+
+			sprintf(block_hex+strlen(block_hex), "%02x", (unsigned char)templ->txsteps.size());
+
+			vector<string>::const_iterator i;
+			for(i = templ->txsteps.begin(); i != templ->txsteps.end(); ++i)
+				sprintf(block_hex + strlen(block_hex), "%s", (*i).c_str());
+
+			strcat(block_hex, "00000000");
+
+			////////////////////////////////////////////////// auxs merkle steps
+
+			vector<string> lresult = coind_aux_merkle_branch(templ->auxs, templ->auxs_size, coind_aux->aux.index);
+			sprintf(block_hex+strlen(block_hex), "%02x", (unsigned char)lresult.size());
+
+			for(i = lresult.begin(); i != lresult.end(); ++i)
+				sprintf(block_hex+strlen(block_hex), "%s", (*i).c_str());
+
+			sprintf(block_hex+strlen(block_hex), "%02x000000", (unsigned char)coind_aux->aux.index);
+
+			////////////////////////////////////////////////// parent header
+
+			strcat(block_hex, submitvalues->header_be);
+
+			bool b = coind_submitgetauxblock(coind_aux, coind_aux->aux.hash, block_hex);
+			if(b)
+			{
+				debuglog("*** ACCEPTED %s %d\n", coind_aux->name, coind_aux->height+1);
+
+				block_add(client->userid, coind_aux->id, coind_aux->height, target_to_diff(coin_target_aux),
+					target_to_diff(hash_int), coind_aux->aux.hash, "");
+			}
+
+			else
+				debuglog("%s %d rejected\n", coind_aux->name, coind_aux->height+1);
+		}
+	}
+
+	if(hash_int <= coin_target)
+	{
+		memset(block_hex, 0, block_size);
+		sprintf(block_hex, "%s%02x%s", submitvalues->header_be, (unsigned char)templ->txcount, submitvalues->coinbase);
+
+		vector<string>::const_iterator i;
+		for(i = templ->txdata.begin(); i != templ->txdata.end(); ++i)
+			sprintf(block_hex+strlen(block_hex), "%s", (*i).c_str());
+
+		if(coind->txmessage)
+			strcat(block_hex, "00");
+
+		bool b = coind_submit(coind, block_hex);
+		if(b)
+		{
+			debuglog("*** ACCEPTED %s %d\n", coind->name, templ->height);
+			job->block_found = true;
+
+			char doublehash2[128];
+			memset(doublehash2, 0, 128);
+
+			sha256_double_hash_hex((char *)submitvalues->header_bin, doublehash2, strlen(submitvalues->header_be)/2);
+
+			char hash1[1024];
+			memset(hash1, 0, 1024);
+
+			string_be(doublehash2, hash1);
+
+			block_add(client->userid, coind->id, templ->height, target_to_diff(coin_target), target_to_diff(hash_int),
+				hash1, submitvalues->hash_be);
+
+//			if(!strcmp(coind->symbol, "HAL"))
+//			{
+//				debuglog("--------------------------------------------------------------\n");
+//				debuglog("hash1 %s\n", hash1);
+//				debuglog("hash2 %s\n", submitvalues->hash_be);
+//			}
+		}
+
+		else
+			debuglog("%s %d rejected\n", coind->name, templ->height);
+	}
+
+	free(block_hex);
+}
+
+bool dump_submit_debug(const char *title, YAAMP_CLIENT *client, YAAMP_JOB *job, char *extranonce2, char *ntime, char *nonce)
+{
+	debuglog("ERROR %s, %s subs %d, job %x, %s, id %x, %d, %s, %s %s\n",
+		title, client->sock->ip, client->extranonce_subscribe, job? job->id: 0, client->extranonce1,
+		client->extranonce1_id, client->extranonce2size, extranonce2, ntime, nonce);
+}
+
+void client_submit_error(YAAMP_CLIENT *client, YAAMP_JOB *job, int id, const char *message, char *extranonce2, char *ntime, char *nonce)
+{
+//	if(job->templ->created+2 > time(NULL))
+	if(job && job->deleted)
+		client_send_result(client, "true");
+
+	else
+	{
+		client_send_error(client, id, message);
+		share_add(client, job, false, extranonce2, ntime, nonce, id);
+
+		client->submit_bad++;
+//		dump_submit_debug(message, client, job, extranonce2, ntime, nonce);
+	}
+
+	object_unlock(job);
+}
+
+bool client_submit(YAAMP_CLIENT *client, json_value *json_params)
+{
+	// submit(worker_name, jobid, extranonce2, ntime, nonce):
+	if(json_params->u.array.length<5)
+	{
+		debuglog("%s - %s bad message\n", client->username, client->sock->ip);
+		client->submit_bad++;
+		return false;
+	}
+
+//	char name[1024];
+	char extranonce2[32];
+	char ntime[32];
+	char nonce[32];
+
+	memset(extranonce2, 0, 32);
+	memset(ntime, 0, 32);
+	memset(nonce, 0, 32);
+
+	int jobid = htoi(json_params->u.array.values[1]->u.string.ptr);
+	strncpy(extranonce2, json_params->u.array.values[2]->u.string.ptr, 31);
+	strncpy(ntime, json_params->u.array.values[3]->u.string.ptr, 31);
+	strncpy(nonce, json_params->u.array.values[4]->u.string.ptr, 31);
+
+//	debuglog("submit %s %d, %s, %s, %s\n", client->sock->ip, jobid, extranonce2, ntime, nonce);
+
+	string_lower(extranonce2);
+	string_lower(ntime);
+	string_lower(nonce);
+
+	YAAMP_JOB *job = (YAAMP_JOB *)object_find(&g_list_job, jobid, true);
+	if(!job)
+	{
+		client_submit_error(client, NULL, 21, "Invalid job id", extranonce2, ntime, nonce);
+		return true;
+	}
+
+	if(job->deleted)
+	{
+		client_send_result(client, "true");
+		object_unlock(job);
+
+		return true;
+	}
+
+	YAAMP_JOB_TEMPLATE *templ = job->templ;
+//	dump_submit_debug(client, job, extranonce2, ntime, nonce);
+
+	if(strlen(nonce) != YAAMP_NONCE_SIZE*2)
+	{
+		client_submit_error(client, job, 20, "Invalid nonce size", extranonce2, ntime, nonce);
+		return true;
+	}
+
+//	if(strcmp(ntime, templ->ntime))
+//	{
+//		client_submit_error(client, job, 23, "Invalid time rolling", extranonce2, ntime, nonce);
+//		return true;
+//	}
+
+	YAAMP_SHARE *share = share_find(job->id, extranonce2, ntime, nonce, client->extranonce1);
+	if(share)
+	{
+		client_submit_error(client, job, 22, "Duplicate share", extranonce2, ntime, nonce);
+		return true;
+	}
+
+	if(strlen(extranonce2) != client->extranonce2size*2)
+	{
+		client_submit_error(client, job, 24, "Invalid extranonce2 size", extranonce2, ntime, nonce);
+		return true;
+	}
+
+	///////////////////////////////////////////////////////////////////////////////////////////
+
+	YAAMP_JOB_VALUES submitvalues;
+	memset(&submitvalues, 0, sizeof(submitvalues));
+
+	build_submit_values(&submitvalues, templ, client->extranonce1, extranonce2, ntime, nonce);
+	if(submitvalues.hash_bin[30] || submitvalues.hash_bin[31])
+	{
+		client_submit_error(client, job, 25, "Invalid share", extranonce2, ntime, nonce);
+		return true;
+	}
+
+	uint64_t hash_int = get_hash_difficulty(submitvalues.hash_bin);
+	uint64_t user_target = diff_to_target(client->difficulty_actual);
+	uint64_t coin_target = decode_compact(templ->nbits);
+
+//	debuglog("%016llx actual\n", hash_int);
+//	debuglog("%016llx target\n", user_target);
+//	debuglog("%016llx coin\n", coin_target);
+
+	if(hash_int > user_target && hash_int > coin_target)
+	{
+		client_submit_error(client, job, 26, "Low difficulty share", extranonce2, ntime, nonce);
+		return true;
+	}
+
+	if(job->coind)
+		client_do_submit(client, job, &submitvalues, extranonce2, ntime, nonce);
+	else
+		remote_submit(client, job, &submitvalues, extranonce2, ntime, nonce);
+
+	client_send_result(client, "true");
+	client_record_difficulty(client);
+	client->submit_bad = 0;
+
+	share_add(client, job, true, extranonce2, ntime, nonce, 0);
+	object_unlock(job);
+
+	return true;
+}
+
+
+
+
+
+
+