#include <ccminer-config.h>

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <stdarg.h>

#include <string.h>

#include <inttypes.h>

#include <unistd.h>

#include <jansson.h>

#include <curl/curl.h>

#include <sys/stat.h>

#include <time.h>

#ifdef WIN32

#include "compat/winansi.h"

#include <winsock2.h>

#include <mstcpip.h>

#else

#include <errno.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#endif

#include "miner.h"

#include "elist.h"

#include "crypto/xmr-rpc.h"

extern pthread_mutex_t stratum_sock_lock;

extern pthread_mutex_t stratum_work_lock;

extern bool opt_debug_diff;

bool opt_tracegpu = false;

struct data_buffer {

void *buf;

size_t len;

};

struct upload_buffer {

};

struct header_info {

};

struct tq_ent {

void *data;

struct list_head q_node;

};

struct thread_q {

};

void applog(int prio, const char *fmt, ...)

}

va_end(ap);

}

extern int gpu_threads;

void gpulog(int prio, int thr_id, const char *fmt, ...)

}

void get_defconfig_path(char *out, size_t bufsize, char *argv0)

}

void format_hashrate_unit(double hashrate, char *output, const char *unit)

}

static void databuf_free(struct data_buffer *db)

}

static size_t all_data_cb(const void *ptr, size_t size, size_t nmemb,

}

static size_t upload_data_cb(void *ptr, size_t size, size_t nmemb,

}

#if LIBCURL_VERSION_NUM >= 0x071200

static int seek_data_cb(void *user_data, curl_off_t offset, int origin)

}

#endif

static size_t resp_hdr_cb(void *ptr, size_t size, size_t nmemb, void *user_data)

}

#if LIBCURL_VERSION_NUM >= 0x070f06

static int sockopt_keepalive_cb(void *userdata, curl_socket_t fd,

}

#endif

static json_t *json_rpc_call(CURL *curl, const char *url,

const char *userpass, const char *rpc_req,

bool longpoll_scan, bool longpoll, bool keepalive, int *curl_err)

{

json_t *val, *err_val, *res_val;

int rc;

struct data_buffer all_data = { 0 };

struct upload_buffer upload_data;

json_error_t err;

struct curl_slist *headers = NULL;

char *httpdata;

char len_hdr[64], hashrate_hdr[64];

char curl_err_str[CURL_ERROR_SIZE] = { 0 };

long timeout = longpoll ? opt_timeout : opt_timeout/2;

struct header_info hi = { 0 };

bool lp_scanning = longpoll_scan && !have_longpoll;

/* it is assumed that 'curl' is freshly [re]initialized at this pt */

if (opt_protocol)

curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);

curl_easy_setopt(curl, CURLOPT_URL, url);

if (opt_cert) {

curl_easy_setopt(curl, CURLOPT_CAINFO, opt_cert);

// ignore CN domain name, allow to move cert files

curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);

}

curl_easy_setopt(curl, CURLOPT_ENCODING, "");

curl_easy_setopt(curl, CURLOPT_FAILONERROR, 0);

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);

curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, all_data_cb);

curl_easy_setopt(curl, CURLOPT_WRITEDATA, &all_data);

curl_easy_setopt(curl, CURLOPT_READFUNCTION, upload_data_cb);

curl_easy_setopt(curl, CURLOPT_READDATA, &upload_data);

#if LIBCURL_VERSION_NUM >= 0x071200

curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, &seek_data_cb);

curl_easy_setopt(curl, CURLOPT_SEEKDATA, &upload_data);

#endif

curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_err_str);

curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);

curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);

curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, resp_hdr_cb);

curl_easy_setopt(curl, CURLOPT_HEADERDATA, &hi);

if (opt_proxy) {

curl_easy_setopt(curl, CURLOPT_PROXY, opt_proxy);

curl_easy_setopt(curl, CURLOPT_PROXYTYPE, opt_proxy_type);

}

if (userpass) {

curl_easy_setopt(curl, CURLOPT_USERPWD, userpass);

curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);

}

#if LIBCURL_VERSION_NUM >= 0x070f06

if (keepalive)

curl_easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_keepalive_cb);

#endif

curl_easy_setopt(curl, CURLOPT_POST, 1);

if (opt_protocol)

applog(LOG_DEBUG, "JSON protocol request:\n%s", rpc_req);

upload_data.buf = rpc_req;

upload_data.len = strlen(rpc_req);

upload_data.pos = 0;

sprintf(len_hdr, "Content-Length: %lu", (unsigned long) upload_data.len);

sprintf(hashrate_hdr, "X-Mining-Hashrate: %llu", (unsigned long long) global_hashrate);

headers = curl_slist_append(headers, "Content-Type: application/json");

headers = curl_slist_append(headers, len_hdr);

headers = curl_slist_append(headers, "User-Agent: " USER_AGENT);

headers = curl_slist_append(headers, "X-Mining-Extensions: longpoll noncerange reject-reason");

headers = curl_slist_append(headers, hashrate_hdr);

headers = curl_slist_append(headers, "Accept:"); /* disable Accept hdr*/

headers = curl_slist_append(headers, "Expect:"); /* disable Expect hdr*/

curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

rc = curl_easy_perform(curl);

if (curl_err != NULL)

*curl_err = rc;

if (rc) {

if (!(longpoll && rc == CURLE_OPERATION_TIMEDOUT)) {

applog(LOG_ERR, "HTTP request failed: %s", curl_err_str);

goto err_out;

}

}

/* If X-Stratum was found, activate Stratum */

if (want_stratum && hi.stratum_url &&

!strncasecmp(hi.stratum_url, "stratum+tcp://", 14) &&

!(opt_proxy && opt_proxy_type == CURLPROXY_HTTP)) {

have_stratum = true;

tq_push(thr_info[stratum_thr_id].q, hi.stratum_url);

hi.stratum_url = NULL;

}

/* If X-Long-Polling was found, activate long polling */

if (lp_scanning && hi.lp_path && !have_stratum) {

have_longpoll = true;

tq_push(thr_info[longpoll_thr_id].q, hi.lp_path);

hi.lp_path = NULL;

}

if (!all_data.buf || !all_data.len) {

if (!have_longpoll) // seems normal on longpoll timeout

applog(LOG_ERR, "Empty data received in json_rpc_call.");

goto err_out;

}

httpdata = (char*) all_data.buf;

if (*httpdata != '{' && *httpdata != '[') {

long errcode = 0;

CURLcode c = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &errcode);

if (c == CURLE_OK && errcode == 401) {

applog(LOG_ERR, "You are not authorized, check your login and password.");

goto err_out;

}

}

val = JSON_LOADS(httpdata, &err);

if (!val) {

applog(LOG_ERR, "JSON decode failed(%d): %s", err.line, err.text);

if (opt_protocol)

applog(LOG_DEBUG, "%s", httpdata);

goto err_out;

}

if (opt_protocol) {

char *s = json_dumps(val, JSON_INDENT(3));

applog(LOG_DEBUG, "JSON protocol response:\n%s\n", s);

free(s);

}

/* JSON-RPC valid response returns a non-null 'result',

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 *s = NULL;

if (err_val) {

s = json_dumps(err_val, 0);

json_t *msg = json_object_get(err_val, "message");

json_t *err_code = json_object_get(err_val, "code");

if (curl_err && json_integer_value(err_code))

*curl_err = (int) json_integer_value(err_code);

if (json_is_string(msg)) {

free(s);

s = strdup(json_string_value(msg));

if (have_longpoll && s && !strcmp(s, "method not getwork")) {

json_decref(err_val);

free(s);

goto err_out;

}

}

json_decref(err_val);

}

else

s = strdup("(unknown reason)");

if (!curl_err || opt_debug)

applog(LOG_ERR, "JSON-RPC call failed: %s", s);

free(s);

goto err_out;

}

if (hi.reason)

json_object_set_new(val, "reject-reason", json_string(hi.reason));

databuf_free(&all_data);

curl_slist_free_all(headers);

curl_easy_reset(curl);

return val;

err_out:

free(hi.lp_path);

free(hi.reason);

free(hi.stratum_url);

databuf_free(&all_data);

curl_slist_free_all(headers);

curl_easy_reset(curl);

return NULL;

}

json_t *json_rpc_call_pool(CURL *curl, struct pool_infos *pool, const char *req,

bool longpoll_scan, bool longpoll, int *curl_err)

{

char userpass[768];

// todo, malloc and store that in pool array

snprintf(userpass, sizeof(userpass), "%s%c%s", pool->user,

strlen(pool->pass)?':':'\0', pool->pass);

return json_rpc_call(curl, pool->url, userpass, req, longpoll_scan, false, false, curl_err);

}

json_t *json_rpc_longpoll(CURL *curl, char *lp_url, struct pool_infos *pool, const char *req, int *curl_err)

{

char userpass[768];

snprintf(userpass, sizeof(userpass), "%s%c%s", pool->user,

strlen(pool->pass)?':':'\0', pool->pass);

// on pool rotate by time-limit, this keepalive can be a problem

bool keepalive = pool->time_limit == 0 || pool->time_limit > opt_timeout;

return json_rpc_call(curl, lp_url, userpass, req, false, true, keepalive, curl_err);

}

json_t *json_load_url(char* cfg_url, json_error_t *err)

{

char err_str[CURL_ERROR_SIZE] = { 0 };

struct data_buffer all_data = { 0 };

int rc = 0; json_t *cfg = NULL;

CURL *curl = curl_easy_init();

if (unlikely(!curl)) {

applog(LOG_ERR, "Remote config init failed!");

return NULL;

}

curl_easy_setopt(curl, CURLOPT_URL, cfg_url);

curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1);

curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 15);

curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, err_str);

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);

curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, all_data_cb);

curl_easy_setopt(curl, CURLOPT_WRITEDATA, &all_data);

if (opt_proxy) {

curl_easy_setopt(curl, CURLOPT_PROXY, opt_proxy);

curl_easy_setopt(curl, CURLOPT_PROXYTYPE, opt_proxy_type);

} else if (getenv("http_proxy")) {

if (getenv("all_proxy"))

curl_easy_setopt(curl, CURLOPT_PROXY, getenv("all_proxy"));

else if (getenv("ALL_PROXY"))

curl_easy_setopt(curl, CURLOPT_PROXY, getenv("ALL_PROXY"));

else

curl_easy_setopt(curl, CURLOPT_PROXY, "");

}

rc = curl_easy_perform(curl);

if (rc) {

applog(LOG_ERR, "Remote config read failed: %s", err_str);

goto err_out;

}

if (!all_data.buf || !all_data.len) {

applog(LOG_ERR, "Empty data received for config");

goto err_out;

}

cfg = JSON_LOADS((char*)all_data.buf, err);

err_out:

curl_easy_cleanup(curl);

return cfg;

}

void *aligned_calloc(int size)

{

const int ALIGN = 64; // cache line

#ifdef _MSC_VER

void* res = _aligned_malloc(size, ALIGN);

memset(res, 0, size);

return res;

#else

void *mem = calloc(1, size+ALIGN+sizeof(uintptr_t));

void **ptr = (void**)((size_t)(((uintptr_t)(mem))+ALIGN+sizeof(uintptr_t)) & ~(ALIGN-1));

ptr[-1] = mem;

return ptr;

#endif

}

void aligned_free(void *ptr)

}

void cbin2hex(char *out, const char *in, size_t len)

}

char *bin2hex(const uchar *in, size_t len)

{

char *s = (char*)malloc((len * 2) + 1);

if (!s)

return NULL;

cbin2hex(s, (const char *) in, len);

return s;

}

bool hex2bin(void *output, const char *hexstr, size_t len)

}

int timeval_subtract(struct timeval *result, struct timeval *x,

}

bool fulltest(const uint32_t *hash, const uint32_t *target)

}

void diff_to_target(uint32_t *target, double diff)

}

void work_set_target(struct work* work, double diff)

}

double target_to_diff(uint32_t* target)

}

#ifdef WIN32

#define socket_blocks() (WSAGetLastError() == WSAEWOULDBLOCK)

#else

#define socket_blocks() (errno == EAGAIN || errno == EWOULDBLOCK)

#endif

static bool send_line(curl_socket_t sock, char *s)

}

bool stratum_send_line(struct stratum_ctx *sctx, char *s)

}

static bool socket_full(curl_socket_t sock, int timeout)

}

bool stratum_socket_full(struct stratum_ctx *sctx, int timeout)

}

#define RBUFSIZE 2048

#define RECVSIZE (RBUFSIZE - 4)

static void stratum_buffer_append(struct stratum_ctx *sctx, const char *s)

}

char *stratum_recv_line(struct stratum_ctx *sctx)

{

ssize_t len, buflen;

char *tok, *sret = NULL;

int timeout = opt_timeout;

if (!sctx->sockbuf)

return NULL;

if (!strstr(sctx->sockbuf, "\n")) {

bool ret = true;

time_t rstart = time(NULL);

if (!socket_full(sctx->sock, timeout)) {

applog(LOG_ERR, "stratum_recv_line timed out");

goto out;

}

do {

char s[RBUFSIZE];

ssize_t n;

memset(s, 0, RBUFSIZE);

n = recv(sctx->sock, s, RECVSIZE, 0);

if (!n) {

ret = false;

break;

}

if (n < 0) {

if (!socket_blocks() || !socket_full(sctx->sock, 1)) {

ret = false;

break;

}

} else

stratum_buffer_append(sctx, s);

} while (time(NULL) - rstart < timeout && !strstr(sctx->sockbuf, "\n"));

if (!ret) {

if (opt_debug) applog(LOG_ERR, "stratum_recv_line failed");

goto out;

}

}