update

cgminer.c

@@ -6723,8 +6723,7 @@ retry_stratum:
 		bool init = pool_tset(pool, &pool->stratum_init);
 
 		if (!init) {
-			bool ret = initiate_stratum(pool) && auth_stratum(pool);
-
+			bool ret = initiate_stratum(pool) && (!pool->extranonce_subscribe || subscribe_extranonce(pool)) && auth_stratum(pool);
 			if (ret)
 				init_stratum_threads(pool);
 			else

configure.ac

@@ -4,7 +4,7 @@ m4_define([v_maj], [4])
 m4_define([v_min], [7])
 m4_define([v_mic], [0])
 ##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##
-m4_define([v_ver], [v_maj.v_min.v_mic-scrypt.2])
+m4_define([v_ver], [v_maj.v_min.v_mic-scrypt-wrk])
 m4_define([lt_rev], m4_eval(v_maj + v_min))
 m4_define([lt_cur], v_mic)
 m4_define([lt_age], v_min)

miner.h

@@ -1353,6 +1353,7 @@ struct pool {
 	char bbversion[12];
 	char nbit[12];
 	char ntime[12];
+	double next_diff;
 	double sdiff;
 
 	struct timeval tv_lastwork;

util.c

@@ -1620,24 +1620,6 @@ double tdiff(struct timeval *end, struct timeval *start)
 	return end->tv_sec - start->tv_sec + (end->tv_usec - start->tv_usec) / 1000000.0;
 }
 
-void check_extranonce_option(struct pool *pool, char * url)
-{
-	char extra_op[16],*extra_op_loc;
-	extra_op_loc = strstr(url,"#");
-        if(extra_op_loc && !pool->extranonce_subscribe)
-        {
-                strcpy(extra_op, extra_op_loc);
-                *extra_op_loc = '\0';
-		if(!strcmp(extra_op,"#xnsub"))
-		{
-			pool->extranonce_subscribe = true;
-			printf("Extra nonce subscribing enabled.");
-			return;
-		}
-        }
-	return;
-}
-
 bool extract_sockaddr(char *url, char **sockaddr_url, char **sockaddr_port)
 {
 	char *url_begin, *url_end, *ipv6_begin, *ipv6_end, *port_start = NULL;
@@ -1682,7 +1664,7 @@ bool extract_sockaddr(char *url, char **sockaddr_url, char **sockaddr_port)
 		char *slash;
 
 		snprintf(port, 6, "%.*s", port_len, port_start);
-		slash = strchr(port, '/');
+		slash = strpbrk(port, "/#");
 		if (slash)
 			*slash = '\0';
 	} else
@@ -1708,6 +1690,9 @@ static enum send_ret __stratum_send(struct pool *pool, char *s, ssize_t len)
 	SOCKETTYPE sock = pool->sock;
 	ssize_t ssent = 0;
 
+	if (opt_protocol)
+		applog(LOG_DEBUG, "SEND: %s", s);
+
 	strcat(s, "\n");
 	len++;
 
@@ -1749,9 +1734,6 @@ bool stratum_send(struct pool *pool, char *s, ssize_t len)
 {
 	enum send_ret ret = SEND_INACTIVE;
 
-	if (opt_protocol)
-		applog(LOG_DEBUG, "SEND: %s", s);
-
 	mutex_lock(&pool->stratum_lock);
 	if (pool->stratum_active)
 		ret = __stratum_send(pool, s, len);
@@ -2007,6 +1989,9 @@ static bool parse_notify(struct pool *pool, json_t *val)
 	snprintf(pool->nbit, 9, "%s", nbit);
 	snprintf(pool->ntime, 9, "%s", ntime);
 	pool->swork.clean = clean;
+	if (pool->next_diff > 0) {
+		pool->sdiff = pool->next_diff;
+	}
 	alloc_len = pool->coinbase_len = cb1_len + pool->n1_len + pool->n2size + cb2_len;
 	pool->nonce2_offset = cb1_len + pool->n1_len;
 
@@ -2118,8 +2103,13 @@ static bool parse_diff(struct pool *pool, json_t *val)
 		return false;
 
 	cg_wlock(&pool->data_lock);
-	old_diff = pool->sdiff;
-	pool->sdiff = diff;
+	if (pool->next_diff > 0) {
+		old_diff = pool->next_diff;
+		pool->next_diff = diff;
+	} else {
+		old_diff = pool->sdiff;
+		pool->next_diff = pool->sdiff = diff;
+	}
 	cg_wunlock(&pool->data_lock);
 
 	if (old_diff != diff) {
@@ -2140,36 +2130,36 @@ static bool parse_diff(struct pool *pool, json_t *val)
 
 static bool parse_extranonce(struct pool *pool, json_t *val)
 {
-        int n2size;
-	char* nonce1;
-        
-        nonce1 = json_array_string(val, 0);
-        if (!valid_hex(nonce1)) {
-                applog(LOG_INFO, "Failed to get valid nonce1 in parse_extranonce");
-                goto out;
-        }
-        n2size = json_integer_value(json_array_get(val, 1));
-        if (n2size < 2 || n2size > 16) {
-                applog(LOG_INFO, "Failed to get valid n2size in parse_extranonce");
-                free(nonce1);
-                goto out;
-        }
-
-        cg_wlock(&pool->data_lock);
-        pool->nonce1 = nonce1;
-        pool->n1_len = strlen(nonce1) / 2;
-        free(pool->nonce1bin);
-        pool->nonce1bin = calloc(pool->n1_len, 1);
-        if (unlikely(!pool->nonce1bin))
-                quithere(1, "Failed to calloc pool->nonce1bin");
-        hex2bin(pool->nonce1bin, pool->nonce1, pool->n1_len);
-        pool->n2size = n2size;
-	applog(LOG_NOTICE, "Pool %d confirmed mining.extranonce.subscribe with extranonce1 %s extran2size %d",
-                               pool->pool_no, pool->nonce1, pool->n2size);
-        cg_wunlock(&pool->data_lock);
+	char s[RBUFSIZE], *nonce1;
+	int n2size;
+
+	nonce1 = json_array_string(val, 0);
+	if (!valid_hex(nonce1)) {
+		applog(LOG_INFO, "Failed to get valid nonce1 in parse_extranonce");
+		return false;
+	}
+	n2size = json_integer_value(json_array_get(val, 1));
+	if (!n2size) {
+		applog(LOG_INFO, "Failed to get valid n2size in parse_extranonce");
+		free(nonce1);
+		return false;
+	}
+
+	cg_wlock(&pool->data_lock);
+	free(pool->nonce1);
+	pool->nonce1 = nonce1;
+	pool->n1_len = strlen(nonce1) / 2;
+	free(pool->nonce1bin);
+	pool->nonce1bin = (unsigned char *)calloc(pool->n1_len, 1);
+	if (unlikely(!pool->nonce1bin))
+		quithere(1, "Failed to calloc pool->nonce1bin");
+	hex2bin(pool->nonce1bin, pool->nonce1, pool->n1_len);
+	pool->n2size = n2size;
+	cg_wunlock(&pool->data_lock);
+
+	applog(LOG_NOTICE, "Pool %d extranonce change requested", pool->pool_no);
+
 	return true;
-out:
-	return false;
 }
 
 static void __suspend_stratum(struct pool *pool)
@@ -2336,13 +2326,12 @@ bool parse_method(struct pool *pool, char *s)
 		ret = parse_diff(pool, params);
 		goto out_decref;
 	}
-	
-	if(!strncasecmp(buf, "mining.set_extranonce", 21)) {
+
+	if (!strncasecmp(buf, "mining.set_extranonce", 21)) {
 		ret = parse_extranonce(pool, params);
 		goto out_decref;
 	}
 
-
 	if (!strncasecmp(buf, "client.reconnect", 16)) {
 		ret = parse_reconnect(pool, params);
 		goto out_decref;
@@ -2369,6 +2358,77 @@ out:
 	return ret;
 }
 
+bool subscribe_extranonce(struct pool *pool)
+{
+	json_t *val = NULL, *res_val, *err_val;
+	char s[RBUFSIZE], *sret = NULL;
+	json_error_t err;
+	bool ret = false;
+
+	sprintf(s, "{\"id\": %d, \"method\": \"mining.extranonce.subscribe\", \"params\": []}",
+		swork_id++);
+
+	if (!stratum_send(pool, s, strlen(s)))
+		return ret;
+
+	/* Parse all data in the queue and anything left should be the response */
+	while (42) {
+		if (!socket_full(pool, DEFAULT_SOCKWAIT / 30)) {
+			applog(LOG_DEBUG, "Timed out waiting for response extranonce.subscribe");
+			/* some pool doesnt send anything, so this is normal */
+			ret = true;
+			goto out;
+		}
+
+		sret = recv_line(pool);
+		if (!sret)
+			return ret;
+		if (parse_method(pool, sret))
+			free(sret);
+		else
+			break;
+	}
+
+	val = JSON_LOADS(sret, &err);
+	free(sret);
+	res_val = json_object_get(val, "result");
+	err_val = json_object_get(val, "error");
+
+	if (!res_val || json_is_false(res_val) || (err_val && !json_is_null(err_val)))  {
+		char *ss;
+
+		if (err_val) {
+			ss = __json_array_string(err_val, 1);
+			if (!ss)
+				ss = (char *)json_string_value(err_val);
+			if (ss && (strcmp(ss, "Method 'subscribe' not found for service 'mining.extranonce'") == 0)) {
+				applog(LOG_INFO, "Cannot subscribe to mining.extranonce for pool %d", pool->pool_no);
+				ret = true;
+				goto out;
+			}
+			if (ss && (strcmp(ss, "Unrecognized request provided") == 0)) {
+				applog(LOG_INFO, "Cannot subscribe to mining.extranonce for pool %d", pool->pool_no);
+				ret = true;
+				goto out;
+			}
+			ss = json_dumps(err_val, JSON_INDENT(3));
+		}
+		else
+			ss = strdup("(unknown reason)");
+		applog(LOG_INFO, "Pool %d JSON extranonce subscribe failed: %s", pool->pool_no, ss);
+		free(ss);
+
+		goto out;
+	}
+
+	ret = true;
+	applog(LOG_INFO, "Stratum extranonce subscribe for pool %d", pool->pool_no);
+
+out:
+	json_decref(val);
+	return ret;
+}
+
 bool auth_stratum(struct pool *pool)
 {
 	json_t *val = NULL, *res_val, *err_val;
@@ -2842,6 +2902,78 @@ void suspend_stratum(struct pool *pool)
 	mutex_unlock(&pool->stratum_lock);
 }
 
+bool extranonce_subscribe(struct pool *pool)
+{
+	bool ret = false, recvd = false, noresume = false, sockd = false;
+	char s[RBUFSIZE], *sret = NULL, *nonce1, *sessionid;
+	json_t *val = NULL, *res_val, *err_val;
+	json_error_t err;
+	int n2size;
+
+//resend:
+//	if (!setup_stratum_socket(pool)) {
+//		sockd = false;
+//		goto out;
+//	}
+//
+//	sockd = true;
+//
+//	if (recvd) {
+//		/* Get rid of any crap lying around if we're resending */
+//		clear_sock(pool);
+//		sprintf(s, "{\"id\": %d, \"method\": \"mining.subscribe\", \"params\": []}", swork_id++);
+//	} else {
+//		if (pool->sessionid)
+//			sprintf(s, "{\"id\": %d, \"method\": \"mining.subscribe\", \"params\": [\""PACKAGE"/"VERSION"\", \"%s\"]}", swork_id++, pool->sessionid);
+//		else
+//			sprintf(s, "{\"id\": %d, \"method\": \"mining.subscribe\", \"params\": [\""PACKAGE"/"VERSION"\"]}", swork_id++);
+//	}
+	sprintf(s,"{\"id\": %d, \"method\": \"mining.extranonce.subscribe\", \"params\": []}", swork_id++);
+	if (__stratum_send(pool, s, strlen(s)) != SEND_OK) {
+		applog(LOG_DEBUG, "Failed to send s in extranonce_subscribe");
+		goto out;
+	}
+
+	if (!socket_full(pool, DEFAULT_SOCKWAIT)) {
+		applog(LOG_DEBUG, "Timed out waiting for response in extranonce_subscribe");
+		goto out;
+	}
+
+	sret = recv_line(pool);
+	if (!sret)
+		goto out;
+
+	recvd = true;
+
+	val = JSON_LOADS(sret, &err);
+	free(sret);
+	if (!val) {
+		applog(LOG_INFO, "JSON decode failed(%d): %s", err.line, err.text);
+		goto out;
+	}
+
+	res_val = json_object_get(val, "result");
+	err_val = json_object_get(val, "error");
+
+	if (!res_val || json_is_null(res_val) ||
+	    (err_val && !json_is_null(err_val))) {
+		char *ss;
+
+		if (err_val)
+			ss = json_dumps(err_val, JSON_INDENT(3));
+		else
+			ss = strdup("(unknown reason)");
+
+		applog(LOG_INFO, "JSON-RPC decode failed: %s", ss);
+
+		free(ss);
+
+		goto out;
+	}
+out:
+	return ret;
+}
+
 bool initiate_stratum(struct pool *pool)
 {
 	bool ret = false, recvd = false, noresume = false, sockd = false;
@@ -2929,6 +3061,8 @@ resend:
 	}
 
 	cg_wlock(&pool->data_lock);
+	free(pool->nonce1);
+	free(pool->sessionid);
 	pool->sessionid = sessionid;
 	pool->nonce1 = nonce1;
 	pool->n1_len = strlen(nonce1) / 2;
@@ -2944,22 +3078,17 @@ resend:
 		applog(LOG_DEBUG, "Pool %d stratum session id: %s", pool->pool_no, pool->sessionid);
 
 	ret = true;
-
 out:
 	if (ret) {
 		if (!pool->stratum_url)
 			pool->stratum_url = pool->sockaddr_url;
 		pool->stratum_active = true;
+		pool->next_diff = 0;
 		pool->sdiff = 1;
 		if (opt_protocol) {
 			applog(LOG_DEBUG, "Pool %d confirmed mining.subscribe with extranonce1 %s extran2size %d",
 			       pool->pool_no, pool->nonce1, pool->n2size);
 		}
-		if(pool->extranonce_subscribe)
-		{
-			sprintf(s,"{\"id\": %d, \"method\": \"mining.extranonce.subscribe\", \"params\": []}", swork_id++);
-		        stratum_send(pool, s, strlen(s));
-		}
 	} else {
 		if (recvd && !noresume) {
 			/* Reset the sessionid used for stratum resuming in case the pool
@@ -2993,6 +3122,8 @@ bool restart_stratum(struct pool *pool)
 		suspend_stratum(pool);
 	if (!initiate_stratum(pool))
 		goto out;
+	if (pool->extranonce_subscribe && !subscribe_extranonce(pool))
+		goto out;
 	if (!auth_stratum(pool))
 		goto out;
 	ret = true;

util.h

@@ -145,9 +145,9 @@ void _recalloc(void **ptr, size_t old, size_t new, const char *file, const char
 #define recalloc(ptr, old, new) _recalloc((void *)&(ptr), old, new, __FILE__, __func__, __LINE__)
 char *recv_line(struct pool *pool);
 bool parse_method(struct pool *pool, char *s);
-void check_extranonce_option(struct pool *pool, char * url);
 bool extract_sockaddr(char *url, char **sockaddr_url, char **sockaddr_port);
-void extranonce_subscribe_stratum(struct pool *pool);
+bool subscribe_extranonce(struct pool *pool);
+//void extranonce_subscribe_stratum(struct pool *pool);
 bool auth_stratum(struct pool *pool);
 bool initiate_stratum(struct pool *pool);
 bool restart_stratum(struct pool *pool);