util.c

/*
 * Copyright 2011-2013 Con Kolivas
 * Copyright 2010 Jeff Garzik
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 of the License, or (at your option)
 * any later version.  See COPYING for more details.
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#include <jansson.h>
#ifdef HAVE_LIBCURL
#include <curl/curl.h>
#endif
#include <time.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#ifndef WIN32
#include <fcntl.h>
# ifdef __linux__
#  include <sys/prctl.h>
# endif
# include <sys/socket.h>
# include <netinet/in.h>
# include <netinet/tcp.h>
# include <netdb.h>
#else
# include <windows.h>
# include <winsock2.h>
# include <ws2tcpip.h>
# include <mmsystem.h>
#endif

#include "miner.h"
#include "elist.h"
#include "compat.h"
#include "util.h"
#include "pool.h"

#define DEFAULT_SOCKWAIT 60
extern double opt_diff_mult;

bool successful_connect = false;
static void keep_sockalive(SOCKETTYPE fd)
{
  const int tcp_one = 1;
#ifdef __linux
  const int tcp_keepidle = 45;
#endif
#ifndef WIN32
  const int tcp_keepintvl = 30;
  int flags = fcntl(fd, F_GETFL, 0);

  fcntl(fd, F_SETFL, O_NONBLOCK | flags);
#else
  u_long flags = 1;

  ioctlsocket(fd, FIONBIO, &flags);
#endif

  setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (const char *)&tcp_one, sizeof(tcp_one));
  if (!opt_delaynet)
#ifndef __linux
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char *)&tcp_one, sizeof(tcp_one));
#else /* __linux */
    setsockopt(fd, SOL_TCP, TCP_NODELAY, (const void *)&tcp_one, sizeof(tcp_one));
  setsockopt(fd, SOL_TCP, TCP_KEEPCNT, &tcp_one, sizeof(tcp_one));
  setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &tcp_keepidle, sizeof(tcp_keepidle));
  setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &tcp_keepintvl, sizeof(tcp_keepintvl));
#endif /* __linux__ */

#ifdef __APPLE_CC__
  setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &tcp_keepintvl, sizeof(tcp_keepintvl));
#endif /* __APPLE_CC__ */

}

struct tq_ent {
  void      *data;
  struct list_head  q_node;
};

#ifdef HAVE_LIBCURL
struct timeval nettime;

struct data_buffer {
  void    *buf;
  size_t    len;
};

struct upload_buffer {
  const void  *buf;
  size_t    len;
};

struct header_info {
  char    *lp_path;
  int   rolltime;
  char    *reason;
  char    *stratum_url;
  bool    hadrolltime;
  bool    canroll;
  bool    hadexpire;
};

static void databuf_free(struct data_buffer *db)
{
  if (db) {
    if (db->buf) free(db->buf);
    memset(db, 0, sizeof(*db));
  }
}

static size_t all_data_cb(const void *ptr, size_t size, size_t nmemb,
        void *user_data)
{
  struct data_buffer *db = (struct data_buffer *)user_data;
  size_t len = size * nmemb;
  size_t oldlen, newlen;
  void *newmem;
  static const unsigned char zero = 0;

  if (len > 0) {
    oldlen = db->len;
    newlen = oldlen + len;

    newmem = realloc(db->buf, newlen + 1);
    if (!newmem)
      return 0;

    db->buf = newmem;
    db->len = newlen;
    memcpy((uint8_t*)db->buf + oldlen, ptr, len);
    memcpy((uint8_t*)db->buf + newlen, &zero, 1); /* null terminate */
  }

  return len;
}

static size_t resp_hdr_cb(void *ptr, size_t size, size_t nmemb, void *user_data)
{
  struct header_info *hi = (struct header_info *)user_data;
  size_t remlen, slen, ptrlen = size * nmemb;
  char *rem, *val = NULL, *key = NULL;
  void *tmp;

  val = (char *)calloc(1, ptrlen);
  key = (char *)calloc(1, ptrlen);
  if (!key || !val)
    goto out;

  tmp = memchr(ptr, ':', ptrlen);
  if (!tmp || (tmp == ptr)) /* skip empty keys / blanks */
    goto out;
  slen = (uint8_t*)tmp - (uint8_t*)ptr;
  if ((slen + 1) == ptrlen) /* skip key w/ no value */
    goto out;
  memcpy(key, ptr, slen);   /* store & nul term key */
  key[slen] = 0;

  rem = (char*)ptr + slen + 1;  /* trim value's leading whitespace */
  remlen = ptrlen - slen - 1;
  while ((remlen > 0) && (isspace(*rem))) {
    remlen--;
    rem++;
  }

  memcpy(val, rem, remlen); /* store value, trim trailing ws */
  val[remlen] = 0;
  while ((*val) && (isspace(val[strlen(val) - 1])))
    val[strlen(val) - 1] = 0;

  if (!*val)      /* skip blank value */
    goto out;

  if (opt_protocol)
    applog(LOG_DEBUG, "HTTP hdr(%s): %s", key, val);

  if (!strcasecmp("X-Roll-Ntime", key)) {
    hi->hadrolltime = true;
    if (!strncasecmp("N", val, 1))
      applog(LOG_DEBUG, "X-Roll-Ntime: N found");
    else {
      hi->canroll = true;

      /* Check to see if expire= is supported and if not, set
       * the rolltime to the default scantime */
      if (strlen(val) > 7 && !strncasecmp("expire=", val, 7)) {
        sscanf(val + 7, "%d", &hi->rolltime);
        hi->hadexpire = true;
      } else
        hi->rolltime = opt_scantime;
      applog(LOG_DEBUG, "X-Roll-Ntime expiry set to %d", hi->rolltime);
    }
  }

  if (!strcasecmp("X-Long-Polling", key)) {
    hi->lp_path = val;  /* steal memory reference */
    val = NULL;
  }

  if (!strcasecmp("X-Reject-Reason", key)) {
    hi->reason = val; /* steal memory reference */
    val = NULL;
  }

  if (!strcasecmp("X-Stratum", key)) {
    hi->stratum_url = val;
    val = NULL;
  }

out:
  free(key);
  free(val);
  return ptrlen;
}

static void last_nettime(struct timeval *last)
{
  rd_lock(&netacc_lock);
  last->tv_sec = nettime.tv_sec;
  last->tv_usec = nettime.tv_usec;
  rd_unlock(&netacc_lock);
}

static void set_nettime(void)
{
  wr_lock(&netacc_lock);
  cgtime(&nettime);
  wr_unlock(&netacc_lock);
}

#if CURL_HAS_KEEPALIVE
static void keep_curlalive(CURL *curl)
{
  const long int keepalive = 1;

  curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, keepalive);
  curl_easy_setopt(curl, CURLOPT_TCP_KEEPIDLE, opt_tcp_keepalive);
  curl_easy_setopt(curl, CURLOPT_TCP_KEEPINTVL, opt_tcp_keepalive);
}
#else
static void keep_curlalive(CURL *curl)
{
  SOCKETTYPE sock;

  curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, (long *)&sock);
  keep_sockalive(sock);
}
#endif

static int curl_debug_cb(__maybe_unused CURL *handle, curl_infotype type,
       __maybe_unused char *data, size_t size, void *userdata)
{
  struct pool *pool = (struct pool *)userdata;

  switch(type) {
    case CURLINFO_HEADER_IN:
    case CURLINFO_DATA_IN:
    case CURLINFO_SSL_DATA_IN:
      pool->sgminer_pool_stats.net_bytes_received += size;
      break;
    case CURLINFO_HEADER_OUT:
    case CURLINFO_DATA_OUT:
    case CURLINFO_SSL_DATA_OUT:
      pool->sgminer_pool_stats.net_bytes_sent += size;
      break;
    case CURLINFO_TEXT:
    default:
      break;
  }
  return 0;
}

json_t *json_rpc_call(CURL *curl, char *curl_err_str, const char *url,
          const char *userpass, const char *rpc_req,
          bool probe, bool longpoll, int *rolltime,
          struct pool *pool, bool share)
{
  long timeout = longpoll ? (60 * 60) : 60;
  struct data_buffer all_data = {NULL, 0};
  struct header_info hi = {NULL, 0, NULL, NULL, false, false, false};
  char len_hdr[64], user_agent_hdr[128];
  struct curl_slist *headers = NULL;
  struct upload_buffer upload_data;
  json_t *val, *err_val, *res_val;
  bool probing = false;
  double byte_count;
  json_error_t err;
  int rc;

  memset(&err, 0, sizeof(err));

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

  if (probe)
    probing = !pool->probed;
  curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);

  // CURLOPT_VERBOSE won't write to stderr if we use CURLOPT_DEBUGFUNCTION
  curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, curl_debug_cb);
  curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)pool);
  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);

  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_ENCODING, "");
  curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);

  /* Shares are staggered already and delays in submission can be costly
   * so do not delay them */
  if (!opt_delaynet || share)
    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_ERRORBUFFER, curl_err_str);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, resp_hdr_cb);
  curl_easy_setopt(curl, CURLOPT_HEADERDATA, &hi);
  curl_easy_setopt(curl, CURLOPT_USE_SSL, CURLUSESSL_TRY);
  if (pool->rpc_proxy) {
    curl_easy_setopt(curl, CURLOPT_PROXY, pool->rpc_proxy);
    curl_easy_setopt(curl, CURLOPT_PROXYTYPE, pool->rpc_proxytype);
  } else if (opt_socks_proxy) {
    curl_easy_setopt(curl, CURLOPT_PROXY, opt_socks_proxy);
    curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
  }
  if (userpass) {
    curl_easy_setopt(curl, CURLOPT_USERPWD, userpass);
    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
  }
  if (longpoll)
    keep_curlalive(curl);
  curl_easy_setopt(curl, CURLOPT_POST, 1);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen (rpc_req));
   curl_easy_setopt(curl, CURLOPT_POSTFIELDS, rpc_req);

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

  sprintf(user_agent_hdr, "User-Agent: %s", PACKAGE_STRING);

  headers = curl_slist_append(headers,
    "Content-type: application/json");
  headers = curl_slist_append(headers,
    "X-Mining-Extensions: longpoll midstate rollntime submitold");

  if (likely(global_hashrate)) {
    char ghashrate[255];

    sprintf(ghashrate, "X-Mining-Hashrate: %llu", global_hashrate);
    headers = curl_slist_append(headers, ghashrate);
  }

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

  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

  if (opt_delaynet) {
    /* Don't delay share submission, but still track the nettime */
    if (!share) {
      long long now_msecs, last_msecs;
      struct timeval now, last;

      cgtime(&now);
      last_nettime(&last);
      now_msecs = (long long)now.tv_sec * 1000;
      now_msecs += now.tv_usec / 1000;
      last_msecs = (long long)last.tv_sec * 1000;
      last_msecs += last.tv_usec / 1000;
      if (now_msecs > last_msecs && now_msecs - last_msecs < 250) {
        struct timespec rgtp;

        rgtp.tv_sec = 0;
        rgtp.tv_nsec = (250 - (now_msecs - last_msecs)) * 1000000;
        nanosleep(&rgtp, NULL);
      }
    }
    set_nettime();
  }

  rc = curl_easy_perform(curl);
  if (rc) {
    applog(LOG_INFO, "HTTP request failed: %s", curl_err_str);
    goto err_out;
  }

  if (!all_data.buf) {
    applog(LOG_DEBUG, "Empty data received in json_rpc_call.");
    goto err_out;
  }

  pool->sgminer_pool_stats.times_sent++;
  if (curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD, &byte_count) == CURLE_OK)
    pool->sgminer_pool_stats.bytes_sent += byte_count;
  pool->sgminer_pool_stats.times_received++;
  if (curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &byte_count) == CURLE_OK)
    pool->sgminer_pool_stats.bytes_received += byte_count;

  if (probing) {
    pool->probed = true;
    /* If X-Long-Polling was found, activate long polling */
    if (hi.lp_path) {
      if (pool->hdr_path != NULL)
        free(pool->hdr_path);
      pool->hdr_path = hi.lp_path;
    } else
      pool->hdr_path = NULL;
    if (hi.stratum_url) {
      pool->stratum_url = hi.stratum_url;
      hi.stratum_url = NULL;
    }
  } else {
    if (hi.lp_path) {
      free(hi.lp_path);
      hi.lp_path = NULL;
    }
    if (hi.stratum_url) {
      free(hi.stratum_url);
      hi.stratum_url = NULL;
    }
  }

  *rolltime = hi.rolltime;
  pool->sgminer_pool_stats.rolltime = hi.rolltime;
  pool->sgminer_pool_stats.hadrolltime = hi.hadrolltime;
  pool->sgminer_pool_stats.canroll = hi.canroll;
  pool->sgminer_pool_stats.hadexpire = hi.hadexpire;

  val = JSON_LOADS((const char *)all_data.buf, &err);
  if (!val) {
    applog(LOG_INFO, "JSON decode failed(%d): %s", err.line, err.text);

    if (opt_protocol)
      applog(LOG_DEBUG, "JSON protocol response:\n%s", (char *)(all_data.buf));

    goto err_out;
  }

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

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

  /* JSON-RPC valid response returns a non-null 'result',
   * and a null 'error'.
   */
  res_val = json_object_get(val, "result");
  err_val = json_object_get(val, "error");

  if (!res_val ||(err_val && !json_is_null(err_val))) {
    char *s;

    if (err_val)
      s = json_dumps(err_val, JSON_INDENT(3));
    else
      s = strdup("(unknown reason)");

    applog(LOG_INFO, "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));
    free(hi.reason);
    hi.reason = NULL;
  }
  successful_connect = true;
  databuf_free(&all_data);
  curl_slist_free_all(headers);
  curl_easy_reset(curl);
  return val;

err_out:
  databuf_free(&all_data);
  curl_slist_free_all(headers);
  curl_easy_reset(curl);
  if (!successful_connect)
    applog(LOG_DEBUG, "Failed to connect in json_rpc_call");
  curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1);
  return NULL;
}
#define PROXY_HTTP  CURLPROXY_HTTP
#define PROXY_HTTP_1_0  CURLPROXY_HTTP_1_0
#define PROXY_SOCKS4  CURLPROXY_SOCKS4
#define PROXY_SOCKS5  CURLPROXY_SOCKS5
#define PROXY_SOCKS4A CURLPROXY_SOCKS4A
#define PROXY_SOCKS5H CURLPROXY_SOCKS5_HOSTNAME
#else /* HAVE_LIBCURL */
#define PROXY_HTTP  0
#define PROXY_HTTP_1_0  1
#define PROXY_SOCKS4  2
#define PROXY_SOCKS5  3
#define PROXY_SOCKS4A 4
#define PROXY_SOCKS5H 5
#endif /* HAVE_LIBCURL */

static struct {
  const char *name;
  proxytypes_t proxytype;
} proxynames[] = {
  { "http:",  PROXY_HTTP },
  { "http0:", PROXY_HTTP_1_0 },
  { "socks4:",  PROXY_SOCKS4 },
  { "socks5:",  PROXY_SOCKS5 },
  { "socks4a:", PROXY_SOCKS4A },
  { "socks5h:", PROXY_SOCKS5H },
  { NULL, (proxytypes_t)NULL }
};

const char *proxytype(proxytypes_t proxytype)
{
  int i;

  for (i = 0; proxynames[i].name; i++)
    if (proxynames[i].proxytype == proxytype)
      return proxynames[i].name;

  return "invalid";
}

char *get_proxy(char *url, struct pool *pool)
{
  pool->rpc_proxy = NULL;

  char *split;
  int plen, len, i;

  for (i = 0; proxynames[i].name; i++) {
    plen = strlen(proxynames[i].name);
    if (strncmp(url, proxynames[i].name, plen) == 0) {
      if (!(split = strchr(url, '|')))
        return url;

      *split = '\0';
      len = split - url;
      pool->rpc_proxy = (char *)malloc(1 + len - plen);
      if (!(pool->rpc_proxy))
        quithere(1, "Failed to malloc rpc_proxy");

      strcpy(pool->rpc_proxy, url + plen);
      extract_sockaddr(pool->rpc_proxy, &pool->sockaddr_proxy_url, &pool->sockaddr_proxy_port);
      pool->rpc_proxytype = proxynames[i].proxytype;
      url = split + 1;
      break;
    }
  }
  return url;
}

/* Adequate size s==len*2 + 1 must be alloced to use this variant */
void __bin2hex(char *s, const unsigned char *p, size_t len)
{
  int i;
  static const char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

  for (i = 0; i < (int)len; i++) {
    *s++ = hex[p[i] >> 4];
    *s++ = hex[p[i] & 0xF];
  }
  *s++ = '\0';
}

/* Returns a malloced array string of a binary value of arbitrary length. The
 * array is rounded up to a 4 byte size to appease architectures that need
 * aligned array  sizes */
char *bin2hex(const unsigned char *p, size_t len)
{
  ssize_t slen;
  char *s;

  slen = len * 2 + 1;
  if (slen % 4)
    slen += 4 - (slen % 4);
  s = (char *)calloc(slen, 1);
  if (unlikely(!s))
    quithere(1, "Failed to calloc");

  __bin2hex(s, p, len);

  return s;
}

/* Does the reverse of bin2hex but does not allocate any ram */
static const int hex2bin_tbl[256] = {
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
bool hex2bin(unsigned char *p, const char *hexstr, size_t len)
{
  int nibble1, nibble2;
  unsigned char idx;
  bool ret = false;

  while (*hexstr && len) {
    if (unlikely(!hexstr[1])) {
      applog(LOG_ERR, "hex2bin str truncated");
      return ret;
    }

    idx = *hexstr++;
    nibble1 = hex2bin_tbl[idx];
    idx = *hexstr++;
    nibble2 = hex2bin_tbl[idx];

    if (unlikely((nibble1 < 0) || (nibble2 < 0))) {
      applog(LOG_ERR, "hex2bin scan failed");
      return ret;
    }

    *p++ = (((unsigned char)nibble1) << 4) | ((unsigned char)nibble2);
    --len;
  }

  if (likely(len == 0 && *hexstr == 0))
    ret = true;
  return ret;
}

bool fulltest(const unsigned char *hash, const unsigned char *target)
{
  uint32_t *hash32 = (uint32_t *)hash;
  uint32_t *target32 = (uint32_t *)target;
  bool rc = true;
  int i;

  for (i = 28 / 4; i >= 0; i--) {
    uint32_t h32tmp = le32toh(hash32[i]);
    uint32_t t32tmp = le32toh(target32[i]);

    if (h32tmp > t32tmp) {
      rc = false;
      break;
    }
    if (h32tmp < t32tmp) {
      rc = true;
      break;
    }
  }

  if (opt_debug) {
    unsigned char hash_swap[32], target_swap[32];
    char *hash_str, *target_str;

    swab256(hash_swap, hash);
    swab256(target_swap, target);
    hash_str = bin2hex(hash_swap, 32);
    target_str = bin2hex(target_swap, 32);

    applog(LOG_DEBUG, " Proof: %s\nTarget: %s\nTrgVal? %s",
      hash_str,
      target_str,
      rc ? "YES (hash <= target)" :
           "no (false positive; hash > target)");

    free(hash_str);
    free(target_str);
  }

  return rc;
}

struct thread_q *tq_new(void)
{
  struct thread_q *tq;

  tq = (struct thread_q *)calloc(1, sizeof(*tq));
  if (!tq)
    return NULL;

  INIT_LIST_HEAD(&tq->q);
  pthread_mutex_init(&tq->mutex, NULL);
  pthread_cond_init(&tq->cond, NULL);

  return tq;
}

void tq_free(struct thread_q *tq)
{
  struct tq_ent *ent, *iter;

  if (!tq)
    return;

  list_for_each_entry_safe(ent, iter, &tq->q, q_node) {
    list_del(&ent->q_node);
    free(ent);
  }

  pthread_cond_destroy(&tq->cond);
  pthread_mutex_destroy(&tq->mutex);

  memset(tq, 0, sizeof(*tq)); /* poison */
  free(tq);
}

static void tq_freezethaw(struct thread_q *tq, bool frozen)
{
  mutex_lock(&tq->mutex);
  tq->frozen = frozen;
  pthread_cond_signal(&tq->cond);
  mutex_unlock(&tq->mutex);
}

void tq_freeze(struct thread_q *tq)
{
  tq_freezethaw(tq, true);
}

void tq_thaw(struct thread_q *tq)
{
  tq_freezethaw(tq, false);
}

bool tq_push(struct thread_q *tq, void *data)
{
  struct tq_ent *ent;
  bool rc = true;

  ent = (struct tq_ent *)calloc(1, sizeof(*ent));
  if (!ent)
    return false;

  ent->data = data;
  INIT_LIST_HEAD(&ent->q_node);

  mutex_lock(&tq->mutex);
  if (!tq->frozen) {
    list_add_tail(&ent->q_node, &tq->q);
  } else {
    free(ent);
    rc = false;
  }
  pthread_cond_signal(&tq->cond);
  mutex_unlock(&tq->mutex);

  return rc;
}

void *tq_pop(struct thread_q *tq, const struct timespec *abstime)
{
  struct tq_ent *ent;
  void *rval = NULL;
  int rc;

  mutex_lock(&tq->mutex);
  if (!list_empty(&tq->q))
    goto pop;

  if (abstime)
    rc = pthread_cond_timedwait(&tq->cond, &tq->mutex, abstime);
  else
    rc = pthread_cond_wait(&tq->cond, &tq->mutex);
  if (rc)
    goto out;
  if (list_empty(&tq->q))
    goto out;
pop:
  ent = list_entry(tq->q.next, struct tq_ent*, q_node);
  rval = ent->data;

  list_del(&ent->q_node);
  free(ent);
out:
  mutex_unlock(&tq->mutex);

  return rval;
}

int thr_info_create(struct thr_info *thr, pthread_attr_t *attr, void *(*start) (void *), void *arg)
{
  cgsem_init(&thr->sem);

  return pthread_create(&thr->pth, attr, start, arg);
}

void thr_info_cancel_join(struct thr_info *thr)
{
  if (!thr)
    return;

  if (PTH(thr) != 0L) {
    pthread_cancel(thr->pth);
    pthread_join(thr->pth, NULL);
    PTH(thr) = 0L;
  }
  cgsem_destroy(&thr->sem);
}

void subtime(struct timeval *a, struct timeval *b)
{
  timersub(a, b, b);
}

void addtime(struct timeval *a, struct timeval *b)
{
  timeradd(a, b, b);
}

bool time_more(struct timeval *a, struct timeval *b)
{
  return timercmp(a, b, >);
}

bool time_less(struct timeval *a, struct timeval *b)
{
  return timercmp(a, b, <);
}

void copy_time(struct timeval *dest, const struct timeval *src)
{
  memcpy(dest, src, sizeof(struct timeval));
}

void timespec_to_val(struct timeval *val, const struct timespec *spec)
{
  val->tv_sec = spec->tv_sec;
  val->tv_usec = spec->tv_nsec / 1000;
}

void timeval_to_spec(struct timespec *spec, const struct timeval *val)
{
  spec->tv_sec = val->tv_sec;
  spec->tv_nsec = val->tv_usec * 1000;
}

void us_to_timeval(struct timeval *val, int64_t us)
{
  lldiv_t tvdiv = lldiv(us, 1000000);

  val->tv_sec = tvdiv.quot;
  val->tv_usec = tvdiv.rem;
}

void us_to_timespec(struct timespec *spec, int64_t us)
{
  lldiv_t tvdiv = lldiv(us, 1000000);

  spec->tv_sec = tvdiv.quot;
  spec->tv_nsec = tvdiv.rem * 1000;
}

void ms_to_timespec(struct timespec *spec, int64_t ms)
{
  lldiv_t tvdiv = lldiv(ms, 1000);

  spec->tv_sec = tvdiv.quot;
  spec->tv_nsec = tvdiv.rem * 1000000;
}

void ms_to_timeval(struct timeval *val, int64_t ms)
{
  lldiv_t tvdiv = lldiv(ms, 1000);

  val->tv_sec = tvdiv.quot;
  val->tv_usec = tvdiv.rem * 1000;
}

void timeraddspec(struct timespec *a, const struct timespec *b)
{
  a->tv_sec += b->tv_sec;
  a->tv_nsec += b->tv_nsec;
  if (a->tv_nsec >= 1000000000) {
    a->tv_nsec -= 1000000000;
    a->tv_sec++;
  }
}

static int __maybe_unused timespec_to_ms(struct timespec *ts)
{
  return ts->tv_sec * 1000 + ts->tv_nsec / 1000000;
}

/* Subtract b from a */
static void __maybe_unused timersubspec(struct timespec *a, const struct timespec *b)
{
  a->tv_sec -= b->tv_sec;
  a->tv_nsec -= b->tv_nsec;
  if (a->tv_nsec < 0) {
    a->tv_nsec += 1000000000;
    a->tv_sec--;
  }
}

/* These are sgminer specific sleep functions that use an absolute nanosecond
 * resolution timer to avoid poor usleep accuracy and overruns. */
#ifdef WIN32
/* Windows start time is since 1601 LOL so convert it to unix epoch 1970. */
#define EPOCHFILETIME (116444736000000000LL)

/* Return the system time as an lldiv_t in decimicroseconds. */
static void decius_time(lldiv_t *lidiv)
{
  FILETIME ft;
  LARGE_INTEGER li;

  GetSystemTimeAsFileTime(&ft);
  li.LowPart  = ft.dwLowDateTime;
  li.HighPart = ft.dwHighDateTime;
  li.QuadPart -= EPOCHFILETIME;

  /* SystemTime is in decimicroseconds so divide by an unusual number */
  *lidiv = lldiv(li.QuadPart, 10000000);
}

/* This is a sgminer gettimeofday wrapper. Since we always call gettimeofday
 * with tz set to NULL, and windows' default resolution is only 15ms, this
 * gives us higher resolution times on windows. */
void cgtime(struct timeval *tv)
{
  lldiv_t lidiv;

  decius_time(&lidiv);
  tv->tv_sec = lidiv.quot;
  tv->tv_usec = lidiv.rem / 10;
}

#else /* WIN32 */
void cgtime(struct timeval *tv)
{
  gettimeofday(tv, NULL);
}

int cgtimer_to_ms(cgtimer_t *cgt)
{
  return timespec_to_ms(cgt);
}

/* Subtracts b from a and stores it in res. */
void cgtimer_sub(cgtimer_t *a, cgtimer_t *b, cgtimer_t *res)
{
  res->tv_sec = a->tv_sec - b->tv_sec;
  res->tv_nsec = a->tv_nsec - b->tv_nsec;
  if (res->tv_nsec < 0) {
    res->tv_nsec += 1000000000;
    res->tv_sec--;
  }
}
#endif /* WIN32 */

#ifdef CLOCK_MONOTONIC /* Essentially just linux */
void cgtimer_time(cgtimer_t *ts_start)
{
  clock_gettime(CLOCK_MONOTONIC, ts_start);
}

static void nanosleep_abstime(struct timespec *ts_end)
{
  int ret;

  do {
    ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, ts_end, NULL);
  } while (ret == EINTR);
}

/* Reentrant version of cgsleep functions allow start time to be set separately
 * from the beginning of the actual sleep, allowing scheduling delays to be
 * counted in the sleep. */
void cgsleep_ms_r(cgtimer_t *ts_start, int ms)
{
  struct timespec ts_end;

  ms_to_timespec(&ts_end, ms);
  timeraddspec(&ts_end, ts_start);
  nanosleep_abstime(&ts_end);
}

void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
  struct timespec ts_end;

  us_to_timespec(&ts_end, us);
  timeraddspec(&ts_end, ts_start);
  nanosleep_abstime(&ts_end);
}
#else /* CLOCK_MONOTONIC */
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
void cgtimer_time(cgtimer_t *ts_start)
{
  clock_serv_t cclock;
  mach_timespec_t mts;

  host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts_start->tv_sec = mts.tv_sec;
  ts_start->tv_nsec = mts.tv_nsec;
}
#elif !defined(WIN32) /* __MACH__ - Everything not linux/macosx/win32 */
void cgtimer_time(cgtimer_t *ts_start)
{
  struct timeval tv;

  cgtime(&tv);
  ts_start->tv_sec = tv->tv_sec;
  ts_start->tv_nsec = tv->tv_usec * 1000;
}
#endif /* __MACH__ */

#ifdef WIN32
/* For windows we use the SystemTime stored as a LARGE_INTEGER as the cgtimer_t
 * typedef, allowing us to have sub-microsecond resolution for times, do simple
 * arithmetic for timer calculations, and use windows' own hTimers to get
 * accurate absolute timeouts. */
int cgtimer_to_ms(cgtimer_t *cgt)
{
  return (int)(cgt->QuadPart / 10000LL);
}

/* Subtracts b from a and stores it in res. */
void cgtimer_sub(cgtimer_t *a, cgtimer_t *b, cgtimer_t *res)
{
  res->QuadPart = a->QuadPart - b->QuadPart;
}

/* Note that cgtimer time is NOT offset by the unix epoch since we use absolute
 * timeouts with hTimers. */
void cgtimer_time(cgtimer_t *ts_start)
{
  FILETIME ft;

  GetSystemTimeAsFileTime(&ft);
  ts_start->LowPart = ft.dwLowDateTime;
  ts_start->HighPart = ft.dwHighDateTime;
}

static void liSleep(LARGE_INTEGER *li, int timeout)
{
  HANDLE hTimer;
  DWORD ret;

  if (unlikely(timeout <= 0))
    return;

  hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
  if (unlikely(!hTimer))
    quit(1, "Failed to create hTimer in liSleep");
  ret = SetWaitableTimer(hTimer, li, 0, NULL, NULL, 0);
  if (unlikely(!ret))
    quit(1, "Failed to SetWaitableTimer in liSleep");
  /* We still use a timeout as a sanity check in case the system time
   * is changed while we're running */
  ret = WaitForSingleObject(hTimer, timeout);
  if (unlikely(ret != WAIT_OBJECT_0 && ret != WAIT_TIMEOUT))
    quit(1, "Failed to WaitForSingleObject in liSleep");
  CloseHandle(hTimer);
}

void cgsleep_ms_r(cgtimer_t *ts_start, int ms)
{
  LARGE_INTEGER li;

  li.QuadPart = ts_start->QuadPart + (int64_t)ms * 10000LL;
  liSleep(&li, ms);
}

void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
  LARGE_INTEGER li;
  int ms;

  li.QuadPart = ts_start->QuadPart + us * 10LL;
  ms = us / 1000;
  if (!ms)
    ms = 1;
  liSleep(&li, ms);
}
#else /* WIN32 */
static void cgsleep_spec(struct timespec *ts_diff, const struct timespec *ts_start)
{
  struct timespec now;

  timeraddspec(ts_diff, ts_start);
  cgtimer_time(&now);
  timersubspec(ts_diff, &now);
  if (unlikely(ts_diff->tv_sec < 0))
    return;
  nanosleep(ts_diff, NULL);
}

void cgsleep_ms_r(cgtimer_t *ts_start, int ms)
{
  struct timespec ts_diff;

  ms_to_timespec(&ts_diff, ms);
  cgsleep_spec(&ts_diff, ts_start);
}

void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
  struct timespec ts_diff;

  us_to_timespec(&ts_diff, us);
  cgsleep_spec(&ts_diff, ts_start);
}
#endif /* WIN32 */
#endif /* CLOCK_MONOTONIC */

void cgsleep_ms(int ms)
{
  cgtimer_t ts_start;

  cgsleep_prepare_r(&ts_start);
  cgsleep_ms_r(&ts_start, ms);
}

void cgsleep_us(int64_t us)
{
  cgtimer_t ts_start;

  cgsleep_prepare_r(&ts_start);
  cgsleep_us_r(&ts_start, us);
}

/* Returns the microseconds difference between end and start times as a double */
double us_tdiff(struct timeval *end, struct timeval *start)
{
  /* Sanity check. We should only be using this for small differences so
   * limit the max to 60 seconds. */
  if (unlikely(end->tv_sec - start->tv_sec > 60))
    return 60000000;
  return (end->tv_sec - start->tv_sec) * 1000000 + (end->tv_usec - start->tv_usec);
}

/* Returns the milliseconds difference between end and start times */
int ms_tdiff(struct timeval *end, struct timeval *start)
{
  /* Like us_tdiff, limit to 1 hour. */
  if (unlikely(end->tv_sec - start->tv_sec > 3600))
    return 3600000;
  return (end->tv_sec - start->tv_sec) * 1000 + (end->tv_usec - start->tv_usec) / 1000;
}

/* Returns the seconds difference between end and start times as a double */
double tdiff(struct timeval *end, struct timeval *start)
{
  return end->tv_sec - start->tv_sec + (end->tv_usec - start->tv_usec) / 1000000.0;
}

bool extract_sockaddr(char *url, char **sockaddr_url, char **sockaddr_port)
{
  char *url_begin, *url_end, *ipv6_begin, *ipv6_end, *port_start = NULL;
  char url_address[256], port[6];
  int url_len, port_len = 0;

  *sockaddr_url = url;
  url_begin = strstr(url, "//");
  if (!url_begin)
    url_begin = url;
  else
    url_begin += 2;

  /* Look for numeric ipv6 entries */
  ipv6_begin = strstr(url_begin, "[");
  ipv6_end = strstr(url_begin, "]");
  if (ipv6_begin && ipv6_end && ipv6_end > ipv6_begin)
    url_end = strstr(ipv6_end, ":");
  else
    url_end = strstr(url_begin, ":");
  if (url_end) {
    url_len = url_end - url_begin;
    port_len = strlen(url_begin) - url_len - 1;
    if (port_len < 1)
      return false;
    port_start = url_end + 1;
  } else
    url_len = strlen(url_begin);

  if (url_len < 1)
    return false;

  if (url_len >= sizeof(url_address))
  {
    applog(LOG_WARNING, "%s: Truncating overflowed address '%.*s'",
           __func__, url_len, url_begin);
    url_len = sizeof(url_address) - 1;
  }

  sprintf(url_address, "%.*s", url_len, url_begin);

  if (port_len) {
    char *slash;

    snprintf(port, 6, "%.*s", port_len, port_start);
    slash = strchr(port, '/');
    if (slash)
      *slash = '\0';
  } else
    strcpy(port, "80");

  *sockaddr_port = strdup(port);
  *sockaddr_url = strdup(url_address);

  return true;
}

enum send_ret {
  SEND_OK,
  SEND_SELECTFAIL,
  SEND_SENDFAIL,
  SEND_INACTIVE
};

/* Send a single command across a socket, appending \n to it. This should all
 * be done under stratum lock except when first establishing the socket */
static enum send_ret __stratum_send(struct pool *pool, char *s, ssize_t len)
{
  SOCKETTYPE sock = pool->sock;
  ssize_t ssent = 0;

  strcat(s, "\n");
  len++;

  while (len > 0 ) {
    struct timeval timeout = {1, 0};
    ssize_t sent;
    fd_set wd;
retry:
    FD_ZERO(&wd);
    FD_SET(sock, &wd);
    if (select(sock + 1, NULL, &wd, NULL, &timeout) < 1) {
      if (interrupted())
        goto retry;
      return SEND_SELECTFAIL;
    }
#ifdef __APPLE__
    sent = send(pool->sock, s + ssent, len, SO_NOSIGPIPE);
#elif WIN32
    sent = send(pool->sock, s + ssent, len, 0);
#else
    sent = send(pool->sock, s + ssent, len, MSG_NOSIGNAL);
#endif
    if (sent < 0) {
      if (!sock_blocks())
        return SEND_SENDFAIL;
      sent = 0;
    }
    ssent += sent;
    len -= sent;
  }

  pool->sgminer_pool_stats.times_sent++;
  pool->sgminer_pool_stats.bytes_sent += ssent;
  pool->sgminer_pool_stats.net_bytes_sent += ssent;
  return SEND_OK;
}

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);
  mutex_unlock(&pool->stratum_lock);

  /* This is to avoid doing applog under stratum_lock */
  switch (ret) {
    default:
    case SEND_OK:
      break;
    case SEND_SELECTFAIL:
      applog(LOG_DEBUG, "Write select failed on %s sock", get_pool_name(pool));
      suspend_stratum(pool);
      break;
    case SEND_SENDFAIL:
      applog(LOG_DEBUG, "Failed to send in stratum_send");
      suspend_stratum(pool);
      break;
    case SEND_INACTIVE:
      applog(LOG_DEBUG, "Stratum send failed due to no pool stratum_active");
      break;
  }
  return (ret == SEND_OK);
}

static bool socket_full(struct pool *pool, int wait)
{
  SOCKETTYPE sock = pool->sock;
  struct timeval timeout;
  fd_set rd;

  if (unlikely(wait < 0))
    wait = 0;
  FD_ZERO(&rd);
  FD_SET(sock, &rd);
  timeout.tv_usec = 0;
  timeout.tv_sec = wait;
  if (select(sock + 1, &rd, NULL, NULL, &timeout) > 0)
    return true;
  return false;
}

/* Check to see if Santa's been good to you */
bool sock_full(struct pool *pool)
{
  if (strlen(pool->sockbuf))
    return true;

  return (socket_full(pool, 0));
}

static void clear_sockbuf(struct pool *pool)
{
  strcpy(pool->sockbuf, "");
}

static void clear_sock(struct pool *pool)
{
  ssize_t n;

  mutex_lock(&pool->stratum_lock);
  do {
    if (pool->sock)
      n = recv(pool->sock, pool->sockbuf, RECVSIZE, 0);
    else
      n = 0;
  } while (n > 0);
  mutex_unlock(&pool->stratum_lock);

  clear_sockbuf(pool);
}

/* Make sure the pool sockbuf is large enough to cope with any coinbase size
 * by reallocing it to a large enough size rounded up to a multiple of RBUFSIZE
 * and zeroing the new memory */
static void recalloc_sock(struct pool *pool, size_t len)
{
  size_t old, newlen;

  old = strlen(pool->sockbuf);
  newlen = old + len + 1;
  if (newlen < pool->sockbuf_size)
    return;
  newlen = newlen + (RBUFSIZE - (newlen % RBUFSIZE));
  // Avoid potentially recursive locking
  // applog(LOG_DEBUG, "Recallocing pool sockbuf to %d", new);
  pool->sockbuf = (char *)realloc(pool->sockbuf, newlen);
  if (!pool->sockbuf)
    quithere(1, "Failed to realloc pool sockbuf");
  memset(pool->sockbuf + old, 0, newlen - old);
  pool->sockbuf_size = newlen;
}

/* Peeks at a socket to find the first end of line and then reads just that
 * from the socket and returns that as a malloced char */
char *recv_line(struct pool *pool)
{
  char *tok, *sret = NULL;
  ssize_t len, buflen;
  int waited = 0;

  if (!strstr(pool->sockbuf, "\n")) {
    struct timeval rstart, now;

    cgtime(&rstart);
    if (!socket_full(pool, DEFAULT_SOCKWAIT)) {
      applog(LOG_DEBUG, "Timed out waiting for data on socket_full");
      goto out;
    }

    do {
      char s[RBUFSIZE];
      size_t slen;
      ssize_t n;

      memset(s, 0, RBUFSIZE);
      n = recv(pool->sock, s, RECVSIZE, 0);
      if (!n) {
        applog(LOG_DEBUG, "Socket closed waiting in recv_line");
        suspend_stratum(pool);
        break;
      }
      cgtime(&now);
      waited = tdiff(&now, &rstart);
      if (n < 0) {
        if (!sock_blocks() || !socket_full(pool, DEFAULT_SOCKWAIT - waited)) {
          applog(LOG_DEBUG, "Failed to recv sock in recv_line");
          suspend_stratum(pool);
          break;
        }
      } else {
        slen = strlen(s);
        recalloc_sock(pool, slen);
        strcat(pool->sockbuf, s);
      }
    } while (waited < DEFAULT_SOCKWAIT && !strstr(pool->sockbuf, "\n"));
  }

  buflen = strlen(pool->sockbuf);

  if ((tok = strtok(pool->sockbuf, "\n")) == NULL) {
    applog(LOG_DEBUG, "Failed to parse a \\n terminated string in recv_line: buffer = %s", pool->sockbuf);
    goto out;
  }
  sret = strdup(tok);
  len = strlen(sret);

  /* Copy what's left in the buffer after the \n, including the
   * terminating \0 */
  if (buflen > len + 1)
    memmove(pool->sockbuf, pool->sockbuf + len + 1, buflen - len + 1);
  else
    strcpy(pool->sockbuf, "");

  pool->sgminer_pool_stats.times_received++;
  pool->sgminer_pool_stats.bytes_received += len;
  pool->sgminer_pool_stats.net_bytes_received += len;
out:
  if (!sret)
    clear_sock(pool);
  else if (opt_protocol)
    applog(LOG_DEBUG, "RECVD: %s", sret);
  return sret;
}

/* Extracts a string value from a json array with error checking. To be used
 * when the value of the string returned is only examined and not to be stored.
 * See json_array_string below */
static char *__json_array_string(json_t *val, unsigned int entry)
{
  json_t *arr_entry;

  if (json_is_null(val))
    return NULL;
  if (!json_is_array(val))
    return NULL;
  if (entry > json_array_size(val))
    return NULL;
  arr_entry = json_array_get(val, entry);
  if (!json_is_string(arr_entry))
    return NULL;

  return (char *)json_string_value(arr_entry);
}

/* Creates a freshly malloced dup of __json_array_string */
static char *json_array_string(json_t *val, unsigned int entry)
{
  char *buf = __json_array_string(val, entry);

  if (buf)
    return strdup(buf);
  return NULL;
}

static char *blank_merkel = "0000000000000000000000000000000000000000000000000000000000000000";

static bool parse_notify(struct pool *pool, json_t *val)
{
  char *job_id, *prev_hash, *coinbase1, *coinbase2, *bbversion, *nbit,
       *ntime, *header, *trie = NULL;
  size_t cb1_len, cb2_len, alloc_len, header_len;
  unsigned char *cb1, *cb2;
  bool clean, ret = false, has_trie = false;
  int merkles, i = 0;
  json_t *arr;

  has_trie = json_array_size(val) == 10;

  job_id = json_array_string(val, i++);
  prev_hash = json_array_string(val, i++);
  if (has_trie) {
    trie = json_array_string(val, i++);
  }
  coinbase1 = json_array_string(val, i++);
  coinbase2 = json_array_string(val, i++);

  arr = json_array_get(val, i++);
  if (!arr || !json_is_array(arr))
    goto out;

  merkles = json_array_size(arr);

  bbversion = json_array_string(val, i++);
  nbit = json_array_string(val, i++);
  ntime = json_array_string(val, i++);
  clean = json_is_true(json_array_get(val, i));

  if (!job_id || !prev_hash || !coinbase1 || !coinbase2 || !bbversion || !nbit || !ntime || (has_trie && !trie)) {
    /* Annoying but we must not leak memory */
    if (job_id)
      free(job_id);
    if (prev_hash)
      free(prev_hash);
    if (trie)
      free(trie);
    if (coinbase1)
      free(coinbase1);
    if (coinbase2)
      free(coinbase2);
    if (bbversion)
      free(bbversion);
    if (nbit)
      free(nbit);
    if (ntime)
      free(ntime);
    goto out;
  }

  cg_wlock(&pool->data_lock);
  free(pool->swork.job_id);
  free(pool->swork.prev_hash);
  free(pool->swork.bbversion);
  free(pool->swork.nbit);
  free(pool->swork.ntime);
  pool->swork.job_id = job_id;
  pool->swork.prev_hash = prev_hash;
  cb1_len = strlen(coinbase1) / 2;
  cb2_len = strlen(coinbase2) / 2;
  pool->swork.bbversion = bbversion;
  pool->swork.nbit = nbit;
  pool->swork.ntime = ntime;
  pool->swork.clean = clean;
  if (pool->next_diff > 0) {
    pool->swork.diff = pool->next_diff;
  }
  alloc_len = pool->swork.cb_len = cb1_len + pool->n1_len + pool->n2size + cb2_len;
  pool->nonce2_offset = cb1_len + pool->n1_len;

  for (i = 0; i < pool->swork.merkles; i++)
    free(pool->swork.merkle_bin[i]);
  if (merkles) {
    pool->swork.merkle_bin = (unsigned char **)realloc(pool->swork.merkle_bin,
             sizeof(char *) * merkles + 1);
    for (i = 0; i < merkles; i++) {
      char *merkle = json_array_string(arr, i);

      pool->swork.merkle_bin[i] = (unsigned char *)malloc(32);
      if (unlikely(!pool->swork.merkle_bin[i]))
        quit(1, "Failed to malloc pool swork merkle_bin");
      hex2bin(pool->swork.merkle_bin[i], merkle, 32);
      free(merkle);
    }
  }
  pool->swork.merkles = merkles;
  if (clean)
    pool->nonce2 = 0;
  pool->merkle_offset = strlen(pool->swork.bbversion) +
            strlen(pool->swork.prev_hash);
  pool->merkle_offset /= 2;
  header = (char *)alloca(257);
  snprintf(header, 257,
    "%s%s%s%s%s%s%s",
    pool->swork.bbversion,
    pool->swork.prev_hash,
    blank_merkel,
    has_trie ? trie : "",
    pool->swork.ntime,
    pool->swork.nbit,
    "00000000" /* nonce */
  );
  header_len = strlen(header);
  memset(header + header_len, '0', 256 - header_len);
  header[256] = '\0';
  if (unlikely(!hex2bin(pool->header_bin, header, 128))) {
    applog(LOG_WARNING, "%s: Failed to convert header to header_bin, got %s", __func__, header);
    pool_failed(pool);
    // TODO: memory leaks? goto out, clean up there?
    return false;
  }

  cb1 = (unsigned char *)calloc(cb1_len, 1);
  if (unlikely(!cb1))
    quithere(1, "Failed to calloc cb1 in parse_notify");
  hex2bin(cb1, coinbase1, cb1_len);

  cb2 = (unsigned char *)calloc(cb2_len, 1);
  if (unlikely(!cb2))
    quithere(1, "Failed to calloc cb2 in parse_notify");
  hex2bin(cb2, coinbase2, cb2_len);

  free(pool->coinbase);
  align_len(&alloc_len);
  pool->coinbase = (unsigned char *)calloc(alloc_len, 1);
  if (unlikely(!pool->coinbase))
    quit(1, "Failed to calloc pool coinbase in parse_notify");
  memcpy(pool->coinbase, cb1, cb1_len);
  memcpy(pool->coinbase + cb1_len, pool->nonce1bin, pool->n1_len);
  // NOTE: gap for nonce2, filled at work generation time
  memcpy(pool->coinbase + cb1_len + pool->n1_len + pool->n2size, cb2, cb2_len);
  cg_wunlock(&pool->data_lock);

  if (opt_protocol) {
    applog(LOG_DEBUG, "job_id: %s", job_id);
    applog(LOG_DEBUG, "prev_hash: %s", prev_hash);
    applog(LOG_DEBUG, "coinbase1: %s", coinbase1);
    applog(LOG_DEBUG, "coinbase2: %s", coinbase2);
    applog(LOG_DEBUG, "bbversion: %s", bbversion);
    applog(LOG_DEBUG, "nbit: %s", nbit);
    applog(LOG_DEBUG, "ntime: %s", ntime);
    applog(LOG_DEBUG, "clean: %s", clean ? "yes" : "no");
  }
  free(coinbase1);
  free(coinbase2);
  free(cb1);
  free(cb2);

  /* A notify message is the closest stratum gets to a getwork */
  pool->getwork_requested++;
  total_getworks++;
  ret = true;
  if (pool == current_pool())
    opt_work_update = true;
out:
  return ret;
}

static bool parse_diff(struct pool *pool, json_t *val)
{
  double old_diff, diff;

  if (opt_diff_mult == 0.0)
    diff = json_number_value(json_array_get(val, 0)) * pool->algorithm.diff_multiplier1;
  else
    diff = json_number_value(json_array_get(val, 0)) * opt_diff_mult;

  if (diff == 0)
    return false;

  cg_wlock(&pool->data_lock);
  if (pool->next_diff > 0) {
    old_diff = pool->next_diff;
    pool->next_diff = diff;
  } else {
    old_diff = pool->swork.diff;
    pool->next_diff = pool->swork.diff = diff;
  }
  cg_wunlock(&pool->data_lock);

  if (old_diff != diff) {
    int idiff = diff;

    if ((double)idiff == diff) {
      applog(pool == current_pool() ? LOG_NOTICE : LOG_DEBUG, "%s difficulty changed to %d", get_pool_name(pool), idiff);
    }
    else {
      applog(pool == current_pool() ? LOG_NOTICE : LOG_DEBUG, "%s difficulty changed to %.3f", get_pool_name(pool), diff);
    }
  }
  else {
    applog(LOG_DEBUG, "%s difficulty set to %f", get_pool_name(pool), diff);
  }

  return true;
}

static bool parse_extranonce(struct pool *pool, json_t *val)
{
  char *nonce1;
  int n2size;

  nonce1 = json_array_string(val, 0);
  if (!nonce1) {
    return false;
  }
  n2size = json_integer_value(json_array_get(val, 1));
  if (!n2size) {
    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, "%s extranonce change requested", get_pool_name(pool));

  return true;
}

static void __suspend_stratum(struct pool *pool)
{
  clear_sockbuf(pool);
  pool->stratum_active = pool->stratum_notify = false;
  if (pool->sock)
    CLOSESOCKET(pool->sock);
  pool->sock = 0;
}

static bool parse_reconnect(struct pool *pool, json_t *val)
{
  if (opt_disable_client_reconnect) {
    applog(LOG_WARNING, "Stratum client.reconnect received but is disabled, not reconnecting.");
    return false;
  }

  char *url, *port, address[256];
  char *sockaddr_url, *stratum_port, *tmp; /* Tempvars. */

  url = (char *)json_string_value(json_array_get(val, 0));
  if (!url)
    url = pool->sockaddr_url;

  port = (char *)json_string_value(json_array_get(val, 1));
  if (!port)
    port = pool->stratum_port;

  snprintf(address, sizeof(address), "%s:%s", url, port);
  if (!extract_sockaddr(address, &sockaddr_url, &stratum_port))
    return false;

  applog(LOG_NOTICE, "Reconnect requested from %s to %s", get_pool_name(pool), address);

  clear_pool_work(pool);

  mutex_lock(&pool->stratum_lock);
  __suspend_stratum(pool);
  tmp = pool->sockaddr_url;
  pool->sockaddr_url = sockaddr_url;
  pool->stratum_url = pool->sockaddr_url;
  free(tmp);
  tmp = pool->stratum_port;
  pool->stratum_port = stratum_port;
  free(tmp);
  mutex_unlock(&pool->stratum_lock);

  if (!restart_stratum(pool)) {
    pool_failed(pool);
    return false;
  }

  return true;
}

static bool send_version(struct pool *pool, json_t *val)
{
  char s[RBUFSIZE];
  int id = json_integer_value(json_object_get(val, "id"));

  if (!id)
    return false;

  sprintf(s, "{\"id\": %d, \"result\": \""PACKAGE"/"CGMINER_VERSION"\", \"error\": null}", id);
  if (!stratum_send(pool, s, strlen(s)))
    return false;

  return true;
}

static bool show_message(struct pool *pool, json_t *val)
{
  char *msg;

  if (!json_is_array(val))
    return false;
  msg = (char *)json_string_value(json_array_get(val, 0));
  if (!msg)
    return false;
  applog(LOG_NOTICE, "%s message: %s", get_pool_name(pool), msg);
  return true;
}

bool parse_method(struct pool *pool, char *s)
{
  json_t *val = NULL, *method, *err_val, *params;
  json_error_t err;
  bool ret = false;
  char *buf;

  if (!s) {
    return ret;
  }

  if (!(val = JSON_LOADS(s, &err))) {
    applog(LOG_INFO, "JSON decode failed(%d): %s", err.line, err.text);
    return ret;
  }

  if (!(method = json_object_get(val, "method"))) {
    goto done;
  }

  err_val = json_object_get(val, "error");
  params = json_object_get(val, "params");

  if (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 method decode failed: %s", ss);

    free(ss);
    goto done;
  }

  buf = (char *)json_string_value(method);
  if (!buf) {
    goto done;
  }

  if (!strncasecmp(buf, "mining.notify", 13)) {
    if (parse_notify(pool, params)) {
      pool->stratum_notify = ret = true;
    }
    else {
      pool->stratum_notify = ret = false;
    }

    goto done;
  }

  if (!strncasecmp(buf, "mining.set_difficulty", 21) && parse_diff(pool, params)) {
    ret = true;
    goto done;
  }

  if (!strncasecmp(buf, "mining.set_extranonce", 21) && parse_extranonce(pool, params)) {
    ret = true;
    goto done;
  }

  if (!strncasecmp(buf, "client.reconnect", 16) && parse_reconnect(pool, params)) {
    ret = true;
    goto done;
  }

  if (!strncasecmp(buf, "client.get_version", 18) && send_version(pool, val)) {
    ret = true;
    goto done;
  }

  if (!strncasecmp(buf, "client.show_message", 19) && show_message(pool, params)) {
    ret = true;
    goto done;
  }

done:
  json_decref(val);
  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;
    }
    else 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 on %s", get_pool_name(pool));
        ret = true;
        goto out;
      }
      if (ss && (strcmp(ss, "Unrecognized request provided") == 0)) {
        applog(LOG_INFO, "Cannot subscribe to mining.extranonce on %s", get_pool_name(pool));
        ret = true;
        goto out;
      }
      ss = json_dumps(err_val, JSON_INDENT(3));
    }
    else
      ss = strdup("(unknown reason)");
    applog(LOG_INFO, "%s JSON stratum auth failed: %s", get_pool_name(pool), ss);
    free(ss);

    goto out;
  }

  ret = true;
  applog(LOG_INFO, "Stratum extranonce subscribe for %s", get_pool_name(pool));

out:
  json_decref(val);
  return ret;
}

bool auth_stratum(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.authorize\", \"params\": [\"%s\", \"%s\"]}",
    swork_id++, pool->rpc_user, pool->rpc_pass);

  if (!stratum_send(pool, s, strlen(s))) {
    return ret;
  }

  /* Parse all data in the queue and anything left should be auth */
  while (42) {
    sret = recv_line(pool);

    if (!sret) {
      return ret;
    }
    else 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_dumps(err_val, JSON_INDENT(3));
    else
      ss = strdup("(unknown reason)");
    applog(LOG_INFO, "%s JSON stratum auth failed: %s", get_pool_name(pool), ss);
    free(ss);

    suspend_stratum(pool);

    goto out;
  }

  ret = true;
  applog(LOG_INFO, "Stratum authorisation success for %s", get_pool_name(pool));
  pool->probed = true;
  successful_connect = true;

out:
  json_decref(val);
  return ret;
}

static int recv_byte(int sockd)
{
  char c;

  if (recv(sockd, &c, 1, 0) != -1)
    return c;

  return -1;
}

static bool http_negotiate(struct pool *pool, int sockd, bool http0)
{
  char buf[1024];
  int i, len;

  if (http0) {
    snprintf(buf, 1024, "CONNECT %s:%s HTTP/1.0\r\n\r\n",
      pool->sockaddr_url, pool->stratum_port);
  } else {
    snprintf(buf, 1024, "CONNECT %s:%s HTTP/1.1\r\nHost: %s:%s\r\n\r\n",
      pool->sockaddr_url, pool->stratum_port, pool->sockaddr_url,
      pool->stratum_port);
  }
  applog(LOG_DEBUG, "Sending proxy %s:%s - %s",
    pool->sockaddr_proxy_url, pool->sockaddr_proxy_port, buf);
  send(sockd, buf, strlen(buf), 0);
  len = recv(sockd, buf, 12, 0);
  if (len <= 0) {
    applog(LOG_WARNING, "Couldn't read from proxy %s:%s after sending CONNECT",
           pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
    return false;
  }
  buf[len] = '\0';
  applog(LOG_DEBUG, "Received from proxy %s:%s - %s",
         pool->sockaddr_proxy_url, pool->sockaddr_proxy_port, buf);
  if (strcmp(buf, "HTTP/1.1 200") && strcmp(buf, "HTTP/1.0 200")) {
    applog(LOG_WARNING, "HTTP Error from proxy %s:%s - %s",
           pool->sockaddr_proxy_url, pool->sockaddr_proxy_port, buf);
    return false;
  }

  /* Ignore unwanted headers till we get desired response */
  for (i = 0; i < 4; i++) {
    buf[i] = recv_byte(sockd);
    if (buf[i] == (char)-1) {
      applog(LOG_WARNING, "Couldn't read HTTP byte from proxy %s:%s",
      pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
      return false;
    }
  }
  while (strncmp(buf, "\r\n\r\n", 4)) {
    for (i = 0; i < 3; i++)
      buf[i] = buf[i + 1];
    buf[3] = recv_byte(sockd);
    if (buf[3] == (char)-1) {
      applog(LOG_WARNING, "Couldn't read HTTP byte from proxy %s:%s",
      pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
      return false;
    }
  }

  applog(LOG_DEBUG, "Success negotiating with %s:%s HTTP proxy",
         pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
  return true;
}

static bool socks5_negotiate(struct pool *pool, int sockd)
{
  unsigned char atyp, uclen;
  unsigned short port;
  char buf[515];
  int i, len;

  buf[0] = 0x05;
  buf[1] = 0x01;
  buf[2] = 0x00;
  applog(LOG_DEBUG, "Attempting to negotiate with %s:%s SOCKS5 proxy",
         pool->sockaddr_proxy_url, pool->sockaddr_proxy_port );
  send(sockd, buf, 3, 0);
  if (recv_byte(sockd) != 0x05 || recv_byte(sockd) != buf[2]) {
    applog(LOG_WARNING, "Bad response from %s:%s SOCKS5 server",
           pool->sockaddr_proxy_url, pool->sockaddr_proxy_port );
    return false;
  }

  buf[0] = 0x05;
  buf[1] = 0x01;
  buf[2] = 0x00;
  buf[3] = 0x03;
  len = (strlen(pool->sockaddr_url));
  if (len > 255)
    len = 255;
  uclen = len;
  buf[4] = (uclen & 0xff);
  memcpy(buf + 5, pool->sockaddr_url, len);
  port = atoi(pool->stratum_port);
  buf[5 + len] = (port >> 8);
  buf[6 + len] = (port & 0xff);
  send(sockd, buf, (7 + len), 0);
  if (recv_byte(sockd) != 0x05 || recv_byte(sockd) != 0x00) {
    applog(LOG_WARNING, "Bad response from %s:%s SOCKS5 server",
      pool->sockaddr_proxy_url, pool->sockaddr_proxy_port );
    return false;
  }

  recv_byte(sockd);
  atyp = recv_byte(sockd);
  if (atyp == 0x01) {
    for (i = 0; i < 4; i++)
      recv_byte(sockd);
  } else if (atyp == 0x03) {
    len = recv_byte(sockd);
    for (i = 0; i < len; i++)
      recv_byte(sockd);
  } else {
    applog(LOG_WARNING, "Bad response from %s:%s SOCKS5 server",
      pool->sockaddr_proxy_url, pool->sockaddr_proxy_port );
    return false;
  }
  for (i = 0; i < 2; i++)
    recv_byte(sockd);

  applog(LOG_DEBUG, "Success negotiating with %s:%s SOCKS5 proxy",
         pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
  return true;
}

static bool socks4_negotiate(struct pool *pool, int sockd, bool socks4a)
{
  unsigned short port;
  in_addr_t inp;
  char buf[515];
  int i, len;
  int ret;

  buf[0] = 0x04;
  buf[1] = 0x01;
  port = atoi(pool->stratum_port);
  buf[2] = port >> 8;
  buf[3] = port & 0xff;
  sprintf(&buf[8], "SGMINER");

  /* See if we've been given an IP address directly to avoid needing to
   * resolve it. */
  inp = inet_addr(pool->sockaddr_url);
  inp = ntohl(inp);
  if ((int)inp != -1)
    socks4a = false;
  else {
    /* Try to extract the IP address ourselves first */
    struct addrinfo servinfobase, *servinfo, hints;

    servinfo = &servinfobase;
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET; /* IPV4 only */
    ret = getaddrinfo(pool->sockaddr_url, NULL, &hints, &servinfo);
    if (!ret) {
      applog(LOG_ERR, "getaddrinfo() in socks4_negotiate() returned %i: %s", ret, gai_strerror(ret));

      struct sockaddr_in *saddr_in = (struct sockaddr_in *)servinfo->ai_addr;

      inp = ntohl(saddr_in->sin_addr.s_addr);
      socks4a = false;
      freeaddrinfo(servinfo);
    }
  }

  if (!socks4a) {
    if ((int)inp == -1) {
      applog(LOG_WARNING, "Invalid IP address specified for socks4 proxy: %s",
             pool->sockaddr_url);
      return false;
    }
    buf[4] = (inp >> 24) & 0xFF;
    buf[5] = (inp >> 16) & 0xFF;
    buf[6] = (inp >>  8) & 0xFF;
    buf[7] = (inp >>  0) & 0xFF;
    send(sockd, buf, 16, 0);
  } else {
    /* This appears to not be working but hopefully most will be
     * able to resolve IP addresses themselves. */
    buf[4] = 0;
    buf[5] = 0;
    buf[6] = 0;
    buf[7] = 1;
    len = strlen(pool->sockaddr_url);
    if (len > 255)
      len = 255;
    memcpy(&buf[16], pool->sockaddr_url, len);
    len += 16;
    buf[len++] = '\0';
    send(sockd, buf, len, 0);
  }

  if (recv_byte(sockd) != 0x00 || recv_byte(sockd) != 0x5a) {
    applog(LOG_WARNING, "Bad response from %s:%s SOCKS4 server",
           pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
    return false;
  }

  for (i = 0; i < 6; i++)
    recv_byte(sockd);

  return true;
}

static void noblock_socket(SOCKETTYPE fd)
{
#ifndef WIN32
  int flags = fcntl(fd, F_GETFL, 0);

  fcntl(fd, F_SETFL, O_NONBLOCK | flags);
#else
  u_long flags = 1;

  ioctlsocket(fd, FIONBIO, &flags);
#endif
}

static void block_socket(SOCKETTYPE fd)
{
#ifndef WIN32
  int flags = fcntl(fd, F_GETFL, 0);

  fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
#else
  u_long flags = 0;

  ioctlsocket(fd, FIONBIO, &flags);
#endif
}

static bool sock_connecting(void)
{
#ifndef WIN32
  return errno == EINPROGRESS;
#else
  return WSAGetLastError() == WSAEWOULDBLOCK;
#endif
}
static bool setup_stratum_socket(struct pool *pool)
{
  struct addrinfo servinfobase, *servinfo, *hints, *p;
  char *sockaddr_url, *sockaddr_port;
  int sockd;
  int ret;

  mutex_lock(&pool->stratum_lock);
  pool->stratum_active = false;
  if (pool->sock) {
    /* FIXME: change to LOG_DEBUG if issue #88 resolved */
    applog(LOG_INFO, "Closing %s socket", get_pool_name(pool));
    CLOSESOCKET(pool->sock);
  }
  pool->sock = 0;
  mutex_unlock(&pool->stratum_lock);

  hints = &pool->stratum_hints;
  memset(hints, 0, sizeof(struct addrinfo));
  hints->ai_family = AF_UNSPEC;
  hints->ai_socktype = SOCK_STREAM;
  servinfo = &servinfobase;

  if (!pool->rpc_proxy && opt_socks_proxy) {
    pool->rpc_proxy = opt_socks_proxy;
    extract_sockaddr(pool->rpc_proxy, &pool->sockaddr_proxy_url, &pool->sockaddr_proxy_port);
    pool->rpc_proxytype = PROXY_SOCKS5;
  }

  if (pool->rpc_proxy) {
    sockaddr_url = pool->sockaddr_proxy_url;
    sockaddr_port = pool->sockaddr_proxy_port;
  } else {
    sockaddr_url = pool->sockaddr_url;
    sockaddr_port = pool->stratum_port;
  }

  ret = getaddrinfo(sockaddr_url, sockaddr_port, hints, &servinfo);
  if (ret) {
    applog(LOG_INFO, "getaddrinfo() in setup_stratum_socket() returned %i: %s", ret, gai_strerror(ret));
    if (!pool->probed) {
      applog(LOG_WARNING, "Failed to resolve (wrong URL?) %s:%s",
             sockaddr_url, sockaddr_port);
      pool->probed = true;
    } else {
      applog(LOG_INFO, "Failed to getaddrinfo for %s:%s",
             sockaddr_url, sockaddr_port);
    }
    return false;
  }

  for (p = servinfo; p != NULL; p = p->ai_next) {
    sockd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
    if (sockd == -1) {
      applog(LOG_DEBUG, "Failed socket");
      continue;
    }

    /* Iterate non blocking over entries returned by getaddrinfo
     * to cope with round robin DNS entries, finding the first one
     * we can connect to quickly. */
    noblock_socket(sockd);
    if (connect(sockd, p->ai_addr, p->ai_addrlen) == -1) {
      struct timeval tv_timeout = {1, 0};
      int selret;
      fd_set rw;

      if (!sock_connecting()) {
        CLOSESOCKET(sockd);
        applog(LOG_DEBUG, "Failed sock connect");
        continue;
      }
retry:
      FD_ZERO(&rw);
      FD_SET(sockd, &rw);
      selret = select(sockd + 1, NULL, &rw, NULL, &tv_timeout);
      if  (selret > 0 && FD_ISSET(sockd, &rw)) {
        socklen_t len;
        int err, n;

        len = sizeof(err);
        n = getsockopt(sockd, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
        if (!n && !err) {
          applog(LOG_DEBUG, "Succeeded delayed connect");
          block_socket(sockd);
          break;
        }
      }
      if (selret < 0 && interrupted())
        goto retry;
      CLOSESOCKET(sockd);
      applog(LOG_DEBUG, "Select timeout/failed connect");
      continue;
    }
    applog(LOG_WARNING, "Succeeded immediate connect");
    block_socket(sockd);

    break;
  }
  if (p == NULL) {
    applog(LOG_INFO, "Failed to connect to stratum on %s:%s",
           sockaddr_url, sockaddr_port);
    freeaddrinfo(servinfo);
    return false;
  }
  freeaddrinfo(servinfo);

  if (pool->rpc_proxy) {
    switch (pool->rpc_proxytype) {
      case PROXY_HTTP_1_0:
        if (!http_negotiate(pool, sockd, true))
          return false;
        break;
      case PROXY_HTTP:
        if (!http_negotiate(pool, sockd, false))
          return false;
        break;
      case PROXY_SOCKS5:
      case PROXY_SOCKS5H:
        if (!socks5_negotiate(pool, sockd))
          return false;
        break;
      case PROXY_SOCKS4:
        if (!socks4_negotiate(pool, sockd, false))
          return false;
        break;
      case PROXY_SOCKS4A:
        if (!socks4_negotiate(pool, sockd, true))
          return false;
        break;
      default:
        applog(LOG_WARNING, "Unsupported proxy type for %s:%s",
               pool->sockaddr_proxy_url, pool->sockaddr_proxy_port);
        return false;
        break;
    }
  }

  if (!pool->sockbuf) {
    pool->sockbuf = (char *)calloc(RBUFSIZE, 1);
    if (!pool->sockbuf)
      quithere(1, "Failed to calloc pool sockbuf");
    pool->sockbuf_size = RBUFSIZE;
  }

  pool->sock = sockd;
  keep_sockalive(sockd);
  return true;
}

static char *get_sessionid(json_t *val)
{
  char *ret = NULL;
  json_t *arr_val;
  int arrsize, i;

  arr_val = json_array_get(val, 0);
  if (!arr_val || !json_is_array(arr_val))
    goto out;
  arrsize = json_array_size(arr_val);
  for (i = 0; i < arrsize; i++) {
    json_t *arr = json_array_get(arr_val, i);
    char *notify;

    if (!arr | !json_is_array(arr))
      break;
    notify = __json_array_string(arr, 0);
    if (!notify)
      continue;
    if (!strncasecmp(notify, "mining.notify", 13)) {
      ret = json_array_string(arr, 1);
      break;
    }
  }
out:
  return ret;
}

void suspend_stratum(struct pool *pool)
{
  applog(LOG_INFO, "Closing socket for stratum %s", get_pool_name(pool));

  mutex_lock(&pool->stratum_lock);
  __suspend_stratum(pool);
  mutex_unlock(&pool->stratum_lock);
}

bool initiate_stratum(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)) {
    /* FIXME: change to LOG_DEBUG when issue #88 resolved */
    applog(LOG_INFO, "setup_stratum_socket() on %s failed", get_pool_name(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"/"CGMINER_VERSION"\", \"%s\"]}", swork_id++, pool->sessionid);
    else
      sprintf(s, "{\"id\": %d, \"method\": \"mining.subscribe\", \"params\": [\""PACKAGE"/"CGMINER_VERSION"\"]}", swork_id++);
  }

  if (__stratum_send(pool, s, strlen(s)) != SEND_OK) {
    applog(LOG_DEBUG, "Failed to send s in initiate_stratum");
    goto out;
  }

  if (!socket_full(pool, DEFAULT_SOCKWAIT)) {
    applog(LOG_DEBUG, "Timed out waiting for response in initiate_stratum");
    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, "Stratum Error: %s", ss);

    free(ss);

    goto out;
  }

  sessionid = get_sessionid(res_val);
  if (!sessionid)
    applog(LOG_DEBUG, "Failed to get sessionid in initiate_stratum");
  nonce1 = json_array_string(res_val, 1);
  if (!nonce1) {
    applog(LOG_INFO, "Failed to get nonce1 in initiate_stratum");
    free(sessionid);
    goto out;
  }
  n2size = json_integer_value(json_array_get(res_val, 2));
  if (n2size < 1)
  {
    applog(LOG_INFO, "Failed to get n2size in initiate_stratum");
    free(sessionid);
    free(nonce1);
    goto out;
  }

  cg_wlock(&pool->data_lock);
  free(pool->nonce1);
  free(pool->sessionid);
  pool->sessionid = sessionid;
  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);

  if (sessionid)
    applog(LOG_DEBUG, "%s stratum session id: %s", get_pool_name(pool), 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->swork.diff = 1;
    if (opt_protocol) {
      applog(LOG_DEBUG, "%s confirmed mining.subscribe with extranonce1 %s extran2size %d",
             get_pool_name(pool), pool->nonce1, pool->n2size);
    }
  } else {
    if (recvd && !noresume) {
      /* Reset the sessionid used for stratum resuming in case the pool
      * does not support it, or does not know how to respond to the
      * presence of the sessionid parameter. */
      cg_wlock(&pool->data_lock);
      free(pool->sessionid);
      free(pool->nonce1);
      pool->sessionid = pool->nonce1 = NULL;
      cg_wunlock(&pool->data_lock);

      applog(LOG_DEBUG, "Failed to resume stratum, trying afresh");
      noresume = true;
      json_decref(val);
      goto resend;
    }
    applog(LOG_DEBUG, "Initiating stratum failed on %s", get_pool_name(pool));
    if (sockd) {
      applog(LOG_DEBUG, "Suspending stratum on %s", get_pool_name(pool));
      suspend_stratum(pool);
    }
  }

  json_decref(val);
  return ret;
}

bool restart_stratum(struct pool *pool)
{
  applog(LOG_DEBUG, "Restarting stratum on pool %s", get_pool_name(pool));

  if (pool->stratum_active)
    suspend_stratum(pool);
  if (!initiate_stratum(pool))
    return false;
  if (pool->extranonce_subscribe && !subscribe_extranonce(pool))
    return false;
  if (!auth_stratum(pool))
    return false;

  return true;
}

void dev_error(struct cgpu_info *dev, enum dev_reason reason)
{
  dev->device_last_not_well = time(NULL);
  dev->device_not_well_reason = reason;

  switch (reason) {
    case REASON_THREAD_FAIL_INIT:
      dev->thread_fail_init_count++;
      break;
    case REASON_THREAD_ZERO_HASH:
      dev->thread_zero_hash_count++;
      break;
    case REASON_THREAD_FAIL_QUEUE:
      dev->thread_fail_queue_count++;
      break;
    case REASON_DEV_SICK_IDLE_60:
      dev->dev_sick_idle_60_count++;
      break;
    case REASON_DEV_DEAD_IDLE_600:
      dev->dev_dead_idle_600_count++;
      break;
    case REASON_DEV_NOSTART:
      dev->dev_nostart_count++;
      break;
    case REASON_DEV_OVER_HEAT:
      dev->dev_over_heat_count++;
      break;
    case REASON_DEV_THERMAL_CUTOFF:
      dev->dev_thermal_cutoff_count++;
      break;
    case REASON_DEV_COMMS_ERROR:
      dev->dev_comms_error_count++;
      break;
    case REASON_DEV_THROTTLE:
      dev->dev_throttle_count++;
      break;
  }
}

/* Realloc an existing string to fit an extra string s, appending s to it. */
void *realloc_strcat(char *ptr, char *s)
{
  size_t old = strlen(ptr), len = strlen(s);
  char *ret;

  if (!len)
    return ptr;

  len += old + 1;
  align_len(&len);

  ret = (char *)malloc(len);
  if (unlikely(!ret))
    quithere(1, "Failed to malloc");

  sprintf(ret, "%s%s", ptr, s);
  free(ptr);
  return ret;
}

void RenameThread(const char* name)
{
  char buf[16];

  snprintf(buf, sizeof(buf), "cg@%s", name);
#if defined(PR_SET_NAME)
  // Only the first 15 characters are used (16 - NUL terminator)
  prctl(PR_SET_NAME, buf, 0, 0, 0);
#elif (defined(__FreeBSD__) || defined(__OpenBSD__))
  pthread_set_name_np(pthread_self(), buf);
#elif defined(MAC_OSX)
  pthread_setname_np(buf);
#else
  // Prevent warnings
  (void)buf;
#endif
}

/* sgminer specific wrappers for true unnamed semaphore usage on platforms
 * that support them and for apple which does not. We use a single byte across
 * a pipe to emulate semaphore behaviour there. */
#ifdef __APPLE__
void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
  int flags, fd, i;

  if (pipe(cgsem->pipefd) == -1)
    quitfrom(1, file, func, line, "Failed pipe errno=%d", errno);

  /* Make the pipes FD_CLOEXEC to allow them to close should we call
   * execv on restart. */
  for (i = 0; i < 2; i++) {
    fd = cgsem->pipefd[i];
    flags = fcntl(fd, F_GETFD, 0);
    flags |= FD_CLOEXEC;
    if (fcntl(fd, F_SETFD, flags) == -1)
      quitfrom(1, file, func, line, "Failed to fcntl errno=%d", errno);
  }
}

void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
  const char buf = 1;
  int ret;

retry:
  ret = write(cgsem->pipefd[1], &buf, 1);
  if (unlikely(ret == 0))
    applog(LOG_WARNING, "Failed to write errno=%d" IN_FMT_FFL, errno, file, func, line);
  else if (unlikely(ret < 0 && interrupted))
    goto retry;
}

void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
  char buf;
  int ret;
retry:
  ret = read(cgsem->pipefd[0], &buf, 1);
  if (unlikely(ret == 0))
    applog(LOG_WARNING, "Failed to read errno=%d" IN_FMT_FFL, errno, file, func, line);
  else if (unlikely(ret < 0 && interrupted))
    goto retry;
}

void cgsem_destroy(cgsem_t *cgsem)
{
  close(cgsem->pipefd[1]);
  close(cgsem->pipefd[0]);
}

/* This is similar to sem_timedwait but takes a millisecond value */
int _cgsem_mswait(cgsem_t *cgsem, int ms, const char *file, const char *func, const int line)
{
  struct timeval timeout;
  int ret, fd;
  fd_set rd;
  char buf;

retry:
  fd = cgsem->pipefd[0];
  FD_ZERO(&rd);
  FD_SET(fd, &rd);
  ms_to_timeval(&timeout, ms);
  ret = select(fd + 1, &rd, NULL, NULL, &timeout);

  if (ret > 0) {
    ret = read(fd, &buf, 1);
    return 0;
  }
  if (likely(!ret))
    return ETIMEDOUT;
  if (interrupted())
    goto retry;
  quitfrom(1, file, func, line, "Failed to sem_timedwait errno=%d cgsem=0x%p", errno, cgsem);
  /* We don't reach here */
  return 0;
}

/* Reset semaphore count back to zero */
void cgsem_reset(cgsem_t *cgsem)
{
  int ret, fd;
  fd_set rd;
  char buf;

  fd = cgsem->pipefd[0];
  FD_ZERO(&rd);
  FD_SET(fd, &rd);
  do {
    struct timeval timeout = {0, 0};

    ret = select(fd + 1, &rd, NULL, NULL, &timeout);
    if (ret > 0)
      ret = read(fd, &buf, 1);
    else if (unlikely(ret < 0 && interrupted()))
      ret = 1;
  } while (ret > 0);
}
#else
void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
  int ret;
  if ((ret = sem_init(cgsem, 0, 0)))
    quitfrom(1, file, func, line, "Failed to sem_init ret=%d errno=%d", ret, errno);
}

void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
  if (unlikely(sem_post(cgsem)))
    quitfrom(1, file, func, line, "Failed to sem_post errno=%d cgsem=0x%p", errno, cgsem);
}

void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
retry:
  if (unlikely(sem_wait(cgsem))) {
    if (interrupted())
      goto retry;
    quitfrom(1, file, func, line, "Failed to sem_wait errno=%d cgsem=0x%p", errno, cgsem);
  }
}

int _cgsem_mswait(cgsem_t *cgsem, int ms, const char *file, const char *func, const int line)
{
  struct timespec abs_timeout, ts_now;
  struct timeval tv_now;
  int ret;

  cgtime(&tv_now);
  timeval_to_spec(&ts_now, &tv_now);
  ms_to_timespec(&abs_timeout, ms);
retry:
  timeraddspec(&abs_timeout, &ts_now);
  ret = sem_timedwait(cgsem, &abs_timeout);

  if (ret) {
    if (likely(sock_timeout()))
      return ETIMEDOUT;
    if (interrupted())
      goto retry;
    quitfrom(1, file, func, line, "Failed to sem_timedwait errno=%d cgsem=0x%p", errno, cgsem);
  }
  return 0;
}

void cgsem_reset(cgsem_t *cgsem)
{
  int ret;

  do {
    ret = sem_trywait(cgsem);
    if (unlikely(ret < 0 && interrupted()))
      ret = 0;
  } while (!ret);
}

void cgsem_destroy(cgsem_t *cgsem)
{
  sem_destroy(cgsem);
}
#endif

/* Provide a completion_timeout helper function for unreliable functions that
 * may die due to driver issues etc that time out if the function fails and
 * can then reliably return. */
struct cg_completion {
  cgsem_t cgsem;
  void (*fn)(void *fnarg);
  void *fnarg;
};

void *completion_thread(void *arg)
{
  struct cg_completion *cgc = (struct cg_completion *)arg;

  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  cgc->fn(cgc->fnarg);
  cgsem_post(&cgc->cgsem);

  return NULL;
}

bool cg_completion_timeout(void *fn, void *fnarg, int timeout)
{
  struct cg_completion *cgc;
  pthread_t pthread;
  bool ret = false;

  cgc = (struct cg_completion *)malloc(sizeof(struct cg_completion));
  if (unlikely(!cgc))
    return ret;
  cgsem_init(&cgc->cgsem);

#ifdef _MSC_VER
  cgc->fn = (void(__cdecl *)(void *))fn;
#else
  cgc->fn = fn;
#endif

  cgc->fnarg = fnarg;

  pthread_create(&pthread, NULL, completion_thread, (void *)cgc);

  ret = cgsem_mswait(&cgc->cgsem, timeout);

  if (ret)
    pthread_cancel(pthread);

  pthread_join(pthread, NULL);
  free(cgc);
  return !ret;
}