markow
/
ckpool
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Create initial stratum proxy connection

master
Con Kolivas 11 years ago
parent
8af64746bf
commit
6ac33e57ac
4 changed files with 290 additions and 81 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 269
      src/generator.c
  2. 2
      src/libckpool.c
  3. 50
      src/libckpool.h
  4. 50
      src/stratifier.c

269
src/generator.c
Unescape View File

@ -10,6 +10,7 @@
#include "config.h"
#include <sys/socket.h>
#include <jansson.h>
#include <string.h>
#include <unistd.h>
@ -18,6 +19,29 @@
#include "generator.h"
#include "bitcoin.h"
/* Per proxied pool instance data */
struct proxy_instance {
char *auth;
char *pass;
char *enonce1;
char *enonce1bin;
char *sessionid;
tv_t last_message;
double diff;
int absolute_shares;
int diff_shares;
tv_t last_share;
int id; /* Message id for sending stratum messages */
bool no_sessionid; /* Doesn't support session id resume on subscribe */
bool no_params; /* Doesn't want any parameters on subscribe */
};
typedef struct proxy_instance proxy_instance_t;
static int gen_loop(proc_instance_t *pi, connsock_t *cs)
{
unixsock_t *us = &pi->us;
@ -101,17 +125,226 @@ out:
return ret;
}
static int server_mode(ckpool_t *ckp, proc_instance_t *pi, connsock_t *cs,
const char *auth, const char *pass)
{
char *userpass = NULL;
gbtbase_t gbt;
int ret = 1;
memset(&gbt, 0, sizeof(gbt));
userpass = strdup(auth);
realloc_strcat(&userpass, ":");
realloc_strcat(&userpass, pass);
cs->auth = http_base64(userpass);
if (!cs->auth) {
LOGWARNING("Failed to create base64 auth from %s", userpass);
goto out;
}
cs->fd = connect_socket(cs->url, cs->port);
if (cs->fd < 0) {
LOGWARNING("FATAL: Failed to connect socket to %s:%s !", cs->url, cs->port);
goto out;
}
keep_sockalive(cs->fd);
/* Test we can connect, authorise and get a block template */
if (!gen_gbtbase(cs, &gbt)) {
LOGWARNING("FATAL: Failed to get test block template from %s:%s auth %s !",
cs->url, cs->port, userpass);
goto out;
}
clear_gbtbase(&gbt);
if (!validate_address(cs, ckp->btcaddress)) {
LOGWARNING("FATAL: Invalid btcaddress: %s !", ckp->btcaddress);
goto out;
}
ret = gen_loop(pi, cs);
out:
close(cs->fd);
dealloc(userpass);
return ret;
}
static bool send_json_msg(connsock_t *cs, json_t *json_msg)
{
int len, sent;
char *s;
s = json_dumps(json_msg, JSON_ESCAPE_SLASH);
realloc_strcat(&s, "\n");
len = strlen(s);
sent = write_socket(cs->fd, s, len);
dealloc(s);
if (sent != len) {
LOGWARNING("Failed to send %d bytes in send_json_msg", len);
return false;
}
return true;
}
static bool connect_proxy(connsock_t *cs)
{
cs->fd = connect_socket(cs->url, cs->port);
if (cs->fd < 0) {
LOGWARNING("Failed to connect socket to %s:%s in connect_proxy",
cs->url, cs->port);
return false;
}
keep_sockalive(cs->fd);
return true;
}
static bool parse_subscribe(connsock_t *cs, proxy_instance_t *proxi)
{
bool ret = false;
int size;
size = read_socket_line(cs);
if (size < 1) {
LOGWARNING("Failed to receive line in parse_subscribe");
goto out;
}
LOGWARNING("Got message: %s", cs->buf);
ret = true;
out:
return ret;
}
static bool subscribe_stratum(connsock_t *cs, proxy_instance_t *proxi)
{
json_t *req;
bool ret = false;
retry:
/* Attempt to reconnect if the pool supports resuming */
if (proxi->sessionid) {
req = json_pack("{s:i,s:s,s:[s,s]}",
"id", proxi->id++,
"method", "mining.subscribe",
"params", "ckproxy", proxi->sessionid);
/* Then attempt to connect with just the client description */
} else if (!proxi->no_params) {
req = json_pack("{s:i,s:s,s:[s]}",
"id", proxi->id++,
"method", "mining.subscribe",
"params", "ckproxy");
/* Then try without any parameters */
} else {
req = json_pack("{s:i,s:s,s:[]}",
"id", proxi->id++,
"method", "mining.subscribe",
"params");
}
ret = send_json_msg(cs, req);
json_decref(req);
if (!ret) {
LOGWARNING("Failed to send message in subscribe_stratum");
close(cs->fd);
goto out;
}
ret = parse_subscribe(cs, proxi);
if (ret)
goto out;
close(cs->fd);
if (proxi->no_params) {
LOGWARNING("Failed all subscription options in subscribe_stratum");
goto out;
}
if (proxi->sessionid) {
LOGNOTICE("Failed sessionid reconnect in subscribe_stratum, retrying without");
proxi->no_sessionid = true;
dealloc(proxi->sessionid);
} else {
LOGNOTICE("Failed connecting with parameters in subscribe_stratum, retrying without");
proxi->no_params = true;
}
ret = connect_proxy(cs);
if (!ret) {
LOGWARNING("Failed to reconnect in subscribe_stratum");
goto out;
}
goto retry;
out:
return ret;
}
static bool auth_stratum(connsock_t *cs, proxy_instance_t *proxi, const char *auth,
const char *pass)
{
json_t *req;
bool ret;
req = json_pack("{s:i,s:s,s:[s,s]}",
"id", proxi->id++,
"method", "mining.authorize",
"params", auth, pass);
ret = send_json_msg(cs, req);
json_decref(req);
if (!ret) {
LOGWARNING("Failed to send message in auth_stratum");
close(cs->fd);
goto out;
}
out:
return ret;
}
static int proxy_loop(proc_instance_t *pi, connsock_t *cs)
{
return 0;
}
static int proxy_mode(ckpool_t *ckp, proc_instance_t *pi, connsock_t *cs,
const char *auth, const char *pass)
{
proxy_instance_t proxi;
int ret;
memset(&proxi, 0, sizeof(proxi));
if (!connect_proxy(cs)) {
LOGWARNING("FATAL: Failed to connect to %s:%s in proxy_mode!",
cs->url, cs->port);
goto out;
}
/* Test we can connect, authorise and get stratum information */
if (!subscribe_stratum(cs, &proxi)) {
LOGWARNING("FATAL: Failed initial subscribe to %s:%s !",
cs->url, cs->port);
goto out;
}
if (!auth_stratum(cs, &proxi, auth, pass)) {
LOGWARNING("FATAL: Failed initial authorise to %s:%s with %s:%s !",
cs->url, cs->port, auth, pass);
goto out;
}
ret = proxy_loop(pi, cs);
out:
close(cs->fd);
free(proxi.enonce1);
free(proxi.enonce1bin);
free(proxi.sessionid);
return ret;
}
/* FIXME: Hard wired to just use config 0 for now */
int generator(proc_instance_t *pi)
{
char *url, *auth, *pass, *userpass = NULL;
ckpool_t *ckp = pi->ckp;
gbtbase_t gbt;
connsock_t cs;
int ret = 1;
memset(&cs, 0, sizeof(cs));
memset(&gbt, 0, sizeof(gbt));
if (!ckp->proxy) {
url = ckp->btcdurl[0];
@ -126,35 +359,11 @@ int generator(proc_instance_t *pi)
LOGWARNING("Failed to extract address from %s", url);
goto out;
}
userpass = strdup(auth);
realloc_strcat(&userpass, ":");
realloc_strcat(&userpass, pass);
cs.auth = http_base64(userpass);
if (!cs.auth) {
LOGWARNING("Failed to create base64 auth from %s", userpass);
goto out;
}
dealloc(userpass);
cs.fd = connect_socket(cs.url, cs.port);
if (cs.fd < 0) {
LOGWARNING("Failed to connect socket to %s:%s", cs.url, cs.port);
goto out;
}
keep_sockalive(cs.fd);
/* Test we can connect, authorise and get a block template */
if (!gen_gbtbase(&cs, &gbt)) {
LOGWARNING("Failed to get test block template from %s:%s auth %s",
cs.url, cs.port, userpass);
goto out;
}
clear_gbtbase(&gbt);
if (!validate_address(&cs, ckp->btcaddress)) {
LOGWARNING("Invalid btcaddress: %s, unable to start!", ckp->btcaddress);
goto out;
}
ret = gen_loop(pi, &cs);
if (!ckp->proxy)
ret = server_mode(ckp, pi, &cs, auth, pass);
else
ret = proxy_mode(ckp, pi, &cs, auth, pass);
out:
/* Clean up here */
dealloc(cs.url);

2
src/libckpool.c
Unescape View File

@ -460,7 +460,7 @@ retry:
LOGERR("Select failed in write_socket");
goto out;
}
ret = write(fd, buf, nbyte);
ret = write_length(fd, buf, nbyte);
if (ret < 0)
LOGWARNING("Failed to write in write_socket");
out:

50
src/libckpool.h
Unescape View File

@ -202,6 +202,56 @@ typedef struct unixsock unixsock_t;
typedef struct proc_instance proc_instance_t;
/* No error checking with these, make sure we know they're valid already! */
static inline void json_strcpy(char *buf, json_t *val, const char *key)
{
strcpy(buf, json_string_value(json_object_get(val, key)));
}
static inline void json_dblcpy(double *dbl, json_t *val, const char *key)
{
*dbl = json_real_value(json_object_get(val, key));
}
static inline void json_uintcpy(uint32_t *u32, json_t *val, const char *key)
{
*u32 = (uint32_t)json_integer_value(json_object_get(val, key));
}
static inline void json_uint64cpy(uint64_t *u64, json_t *val, const char *key)
{
*u64 = (uint64_t)json_integer_value(json_object_get(val, key));
}
static inline void json_intcpy(int *i, json_t *val, const char *key)
{
*i = json_integer_value(json_object_get(val, key));
}
static inline void json_strdup(char **buf, json_t *val, const char *key)
{
*buf = strdup(json_string_value(json_object_get(val, key)));
}
static inline void json_set_string(json_t *val, const char *key, const char *str)
{
json_object_set_nocheck(val, key, json_string(str));
}
static inline void json_set_int(json_t *val, const char *key, int integer)
{
json_object_set_new_nocheck(val, key, json_integer(integer));
}
static inline void json_set_double(json_t *val, const char *key, double real)
{
json_object_set_new_nocheck(val, key, json_real(real));
}
static inline void json_set_bool(json_t *val, const char *key, bool boolean)
{
json_object_set_new_nocheck(val, key, json_boolean(boolean));
}
void rename_proc(const char *name);
void create_pthread(pthread_t *thread, void *(*start_routine)(void *), void *arg);
void join_pthread(pthread_t thread);

50
src/stratifier.c
Unescape View File

@ -212,56 +212,6 @@ static share_t *shares;
static cklock_t share_lock;
/* No error checking with these, make sure we know they're valid already! */
static inline void json_strcpy(char *buf, json_t *val, const char *key)
{
strcpy(buf, json_string_value(json_object_get(val, key)));
}
static inline void json_dblcpy(double *dbl, json_t *val, const char *key)
{
*dbl = json_real_value(json_object_get(val, key));
}
static inline void json_uintcpy(uint32_t *u32, json_t *val, const char *key)
{
*u32 = (uint32_t)json_integer_value(json_object_get(val, key));
}
static inline void json_uint64cpy(uint64_t *u64, json_t *val, const char *key)
{
*u64 = (uint64_t)json_integer_value(json_object_get(val, key));
}
static inline void json_intcpy(int *i, json_t *val, const char *key)
{
*i = json_integer_value(json_object_get(val, key));
}
static inline void json_strdup(char **buf, json_t *val, const char *key)
{
*buf = strdup(json_string_value(json_object_get(val, key)));
}
static inline void json_set_string(json_t *val, const char *key, const char *str)
{
json_object_set_nocheck(val, key, json_string(str));
}
static inline void json_set_int(json_t *val, const char *key, int integer)
{
json_object_set_new_nocheck(val, key, json_integer(integer));
}
static inline void json_set_double(json_t *val, const char *key, double real)
{
json_object_set_new_nocheck(val, key, json_real(real));
}
static inline void json_set_bool(json_t *val, const char *key, bool boolean)
{
json_object_set_new_nocheck(val, key, json_boolean(boolean));
}
static void generate_coinbase(ckpool_t *ckp, workbase_t *wb)
{
char header[228];

Write Preview
Loading…
Cancel
Save