Rename files.

src/base/kernel/interfaces/IClientListener.h

@@ -0,0 +1,59 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_ICLIENTLISTENER_H
+#define XMRIG_ICLIENTLISTENER_H
+
+
+#include <stdint.h>
+
+
+#include "rapidjson/fwd.h"
+
+
+namespace xmrig {
+
+
+class Client;
+class Job;
+class SubmitResult;
+
+
+class IClientListener
+{
+public:
+    virtual ~IClientListener() = default;
+
+    virtual void onClose(Client *client, int failures)                                           = 0;
+    virtual void onJobReceived(Client *client, const Job &job, const rapidjson::Value &params)   = 0;
+    virtual void onLogin(Client *client, rapidjson::Document &doc, rapidjson::Value &params)     = 0;
+    virtual void onLoginSuccess(Client *client)                                                  = 0;
+    virtual void onResultAccepted(Client *client, const SubmitResult &result, const char *error) = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_ICLIENTLISTENER_H

src/base/kernel/interfaces/IStrategy.h

@@ -0,0 +1,59 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_ISTRATEGY_H
+#define XMRIG_ISTRATEGY_H
+
+
+#include <stdint.h>
+
+
+class JobResult;
+
+
+namespace xmrig {
+
+
+class Algorithm;
+
+
+class IStrategy
+{
+public:
+    virtual ~IStrategy() = default;
+
+    virtual bool isActive() const                      = 0;
+    virtual int64_t submit(const JobResult &result)    = 0;
+    virtual void connect()                             = 0;
+    virtual void resume()                              = 0;
+    virtual void setAlgo(const Algorithm &algo)        = 0;
+    virtual void stop()                                = 0;
+    virtual void tick(uint64_t now)                    = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_ISTRATEGY_H

src/base/kernel/interfaces/IStrategyListener.h

@@ -0,0 +1,56 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_ISTRATEGYLISTENER_H
+#define XMRIG_ISTRATEGYLISTENER_H
+
+
+#include <stdint.h>
+
+
+namespace xmrig {
+
+
+class Client;
+class IStrategy;
+class Job;
+class SubmitResult;
+
+
+class IStrategyListener
+{
+public:
+    virtual ~IStrategyListener() = default;
+
+    virtual void onActive(IStrategy *strategy, Client *client)                                                        = 0;
+    virtual void onJob(IStrategy *strategy, Client *client, const Job &job)                                           = 0;
+    virtual void onPause(IStrategy *strategy)                                                                         = 0;
+    virtual void onResultAccepted(IStrategy *strategy, Client *client, const SubmitResult &result, const char *error) = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_ISTRATEGYLISTENER_H

src/base/net/stratum/Client.h

@@ -0,0 +1,191 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CLIENT_H
+#define XMRIG_CLIENT_H
+
+
+#include <bitset>
+#include <map>
+#include <uv.h>
+#include <vector>
+
+
+#include "base/net/stratum/Id.h"
+#include "base/net/stratum/Job.h"
+#include "base/net/stratum/Pool.h"
+#include "base/net/stratum/SubmitResult.h"
+#include "base/net/tools/Storage.h"
+#include "common/crypto/Algorithm.h"
+#include "rapidjson/fwd.h"
+
+
+typedef struct bio_st BIO;
+
+
+namespace xmrig {
+
+
+class IClientListener;
+class JobResult;
+
+
+class Client
+{
+public:
+    enum SocketState {
+        UnconnectedState,
+        HostLookupState,
+        ConnectingState,
+        ConnectedState,
+        ClosingState
+    };
+
+    enum Extension {
+        EXT_ALGO,
+        EXT_NICEHASH,
+        EXT_CONNECT,
+        EXT_KEEPALIVE,
+        EXT_MAX
+    };
+
+    constexpr static int kResponseTimeout = 20 * 1000;
+
+#   ifndef XMRIG_NO_TLS
+    constexpr static int kInputBufferSize = 1024 * 16;
+#   else
+    constexpr static int kInputBufferSize = 1024 * 2;
+#   endif
+
+    Client(int id, const char *agent, IClientListener *listener);
+    ~Client();
+
+    bool disconnect();
+    const char *tlsFingerprint() const;
+    const char *tlsVersion() const;
+    int64_t submit(const JobResult &result);
+    void connect();
+    void connect(const Pool &pool);
+    void deleteLater();
+    void setPool(const Pool &pool);
+    void tick(uint64_t now);
+
+    inline bool isEnabled() const                     { return m_enabled; }
+    inline bool isReady() const                       { return m_state == ConnectedState && m_failures == 0; }
+    inline const char *host() const                   { return m_pool.host(); }
+    inline const char *ip() const                     { return m_ip; }
+    inline const Job &job() const                     { return m_job; }
+    inline int id() const                             { return m_id; }
+    inline SocketState state() const                  { return m_state; }
+    inline uint16_t port() const                      { return m_pool.port(); }
+    inline void setAlgo(const Algorithm &algo)        { m_pool.setAlgo(algo); }
+    inline void setEnabled(bool enabled)              { m_enabled = enabled; }
+    inline void setQuiet(bool quiet)                  { m_quiet = quiet; }
+    inline void setRetries(int retries)               { m_retries = retries; }
+    inline void setRetryPause(int ms)                 { m_retryPause = ms; }
+
+    template<Extension ext> inline bool has() const noexcept { return m_extensions.test(ext); }
+
+private:
+    class Tls;
+
+    bool close();
+    bool isCriticalError(const char *message);
+    bool isTLS() const;
+    bool parseJob(const rapidjson::Value &params, int *code);
+    bool parseLogin(const rapidjson::Value &result, int *code);
+    bool send(BIO *bio);
+    bool verifyAlgorithm(const Algorithm &algorithm) const;
+    int resolve(const char *host);
+    int64_t send(const rapidjson::Document &doc);
+    int64_t send(size_t size);
+    void connect(const std::vector<addrinfo*> &ipv4, const std::vector<addrinfo*> &ipv6);
+    void connect(sockaddr *addr);
+    void handshake();
+    void login();
+    void onClose();
+    void parse(char *line, size_t len);
+    void parseExtensions(const rapidjson::Value &result);
+    void parseNotification(const char *method, const rapidjson::Value &params, const rapidjson::Value &error);
+    void parseResponse(int64_t id, const rapidjson::Value &result, const rapidjson::Value &error);
+    void ping();
+    void read();
+    void reconnect();
+    void setState(SocketState state);
+    void startTimeout();
+
+    inline bool isQuiet() const                                   { return m_quiet || m_failures >= m_retries; }
+    inline void setExtension(Extension ext, bool enable) noexcept { m_extensions.set(ext, enable); }
+
+    static void onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
+    static void onClose(uv_handle_t *handle);
+    static void onConnect(uv_connect_t *req, int status);
+    static void onRead(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf);
+    static void onResolved(uv_getaddrinfo_t *req, int status, struct addrinfo *res);
+
+    static inline Client *getClient(void *data) { return m_storage.get(data); }
+
+    addrinfo m_hints;
+    bool m_enabled;
+    bool m_ipv6;
+    bool m_quiet;
+    char m_buf[kInputBufferSize];
+    char m_ip[46];
+    char m_sendBuf[2048];
+    const char *m_agent;
+    IClientListener *m_listener;
+    Id m_rpcId;
+    int m_id;
+    int m_retries;
+    int m_retryPause;
+    int64_t m_failures;
+    Job m_job;
+    Pool m_pool;
+    size_t m_recvBufPos;
+    SocketState m_state;
+    std::bitset<EXT_MAX> m_extensions;
+    std::map<int64_t, SubmitResult> m_results;
+    Tls *m_tls;
+    uint64_t m_expire;
+    uint64_t m_jobs;
+    uint64_t m_keepAlive;
+    uintptr_t m_key;
+    uv_buf_t m_recvBuf;
+    uv_getaddrinfo_t m_resolver;
+    uv_stream_t *m_stream;
+    uv_tcp_t *m_socket;
+
+    static int64_t m_sequence;
+    static Storage<Client> m_storage;
+};
+
+
+template<> inline bool Client::has<Client::EXT_NICEHASH>() const noexcept  { return m_extensions.test(EXT_NICEHASH) || m_pool.isNicehash(); }
+template<> inline bool Client::has<Client::EXT_KEEPALIVE>() const noexcept { return m_extensions.test(EXT_KEEPALIVE) || m_pool.keepAlive() > 0; }
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_CLIENT_H */

src/base/net/stratum/Id.h

@@ -0,0 +1,98 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_ID_H
+#define XMRIG_ID_H
+
+
+#include <string.h>
+
+
+namespace xmrig {
+
+
+class Id
+{
+public:
+    inline Id() :
+        m_data()
+    {
+    }
+
+
+    inline Id(const char *id, size_t sizeFix = 0)
+    {
+        setId(id, sizeFix);
+    }
+
+
+    inline bool operator==(const Id &other) const
+    {
+        return memcmp(m_data, other.m_data, sizeof(m_data)) == 0;
+    }
+
+
+    inline bool operator!=(const Id &other) const
+    {
+        return memcmp(m_data, other.m_data, sizeof(m_data)) != 0;
+    }
+
+
+    Id &operator=(const Id &other)
+    {
+        memcpy(m_data, other.m_data, sizeof(m_data));
+
+        return *this;
+    }
+
+
+    inline bool setId(const char *id, size_t sizeFix = 0)
+    {
+        memset(m_data, 0, sizeof(m_data));
+        if (!id) {
+            return false;
+        }
+
+        const size_t size = strlen(id);
+        if (size >= sizeof(m_data)) {
+            return false;
+        }
+
+        memcpy(m_data, id, size - sizeFix);
+        return true;
+    }
+
+
+    inline const char *data() const { return m_data; }
+    inline bool isValid() const     { return *m_data != '\0'; }
+
+
+private:
+    char m_data[64];
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_ID_H */

src/base/net/stratum/Job.cpp

@@ -0,0 +1,266 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018      SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <assert.h>
+#include <string.h>
+
+
+#include "base/net/stratum/Job.h"
+
+
+unsigned char hf_hex2bin(char c, bool &err)
+{
+    if (c >= '0' && c <= '9') {
+        return c - '0';
+    }
+    else if (c >= 'a' && c <= 'f') {
+        return c - 'a' + 0xA;
+    }
+    else if (c >= 'A' && c <= 'F') {
+        return c - 'A' + 0xA;
+    }
+
+    err = true;
+    return 0;
+}
+
+
+char hf_bin2hex(unsigned char c)
+{
+    if (c <= 0x9) {
+        return '0' + c;
+    }
+
+    return 'a' - 0xA + c;
+}
+
+
+xmrig::Job::Job() :
+    m_autoVariant(false),
+    m_nicehash(false),
+    m_poolId(-2),
+    m_threadId(-1),
+    m_size(0),
+    m_diff(0),
+    m_target(0),
+    m_blob(),
+    m_height(0)
+{
+}
+
+
+xmrig::Job::Job(int poolId, bool nicehash, const Algorithm &algorithm, const Id &clientId) :
+    m_autoVariant(algorithm.variant() == VARIANT_AUTO),
+    m_nicehash(nicehash),
+    m_poolId(poolId),
+    m_threadId(-1),
+    m_size(0),
+    m_diff(0),
+    m_target(0),
+    m_blob(),
+    m_height(0),
+    m_algorithm(algorithm),
+    m_clientId(clientId)
+{
+}
+
+
+xmrig::Job::~Job()
+{
+}
+
+
+bool xmrig::Job::isEqual(const Job &other) const
+{
+    return m_id == other.m_id && m_clientId == other.m_clientId && memcmp(m_blob, other.m_blob, sizeof(m_blob)) == 0;
+}
+
+
+bool xmrig::Job::setBlob(const char *blob)
+{
+    if (!blob) {
+        return false;
+    }
+
+    m_size = strlen(blob);
+    if (m_size % 2 != 0) {
+        return false;
+    }
+
+    m_size /= 2;
+    if (m_size < 76 || m_size >= sizeof(m_blob)) {
+        return false;
+    }
+
+    if (!fromHex(blob, (int) m_size * 2, m_blob)) {
+        return false;
+    }
+
+    if (*nonce() != 0 && !m_nicehash) {
+        m_nicehash = true;
+    }
+
+    if (m_autoVariant) {
+        m_algorithm.setVariant(variant());
+    }
+
+    if (!m_algorithm.isForced()) {
+        if (m_algorithm.variant() == VARIANT_XTL && m_blob[0] >= 9) {
+            m_algorithm.setVariant(VARIANT_HALF);
+        }
+        else if (m_algorithm.variant() == VARIANT_MSR && m_blob[0] >= 8) {
+            m_algorithm.setVariant(VARIANT_HALF);
+        }
+        else if (m_algorithm.variant() == VARIANT_WOW && m_blob[0] < 11) {
+            m_algorithm.setVariant(VARIANT_2);
+        }
+        else if (m_algorithm.variant() == VARIANT_RWZ && m_blob[0] < 12) {
+            m_algorithm.setVariant(VARIANT_2);
+        }
+        else if (m_algorithm.variant() == VARIANT_ZLS && m_blob[0] < 8) {
+            m_algorithm.setVariant(VARIANT_2);
+        }
+    }
+
+#   ifdef XMRIG_PROXY_PROJECT
+    memset(m_rawBlob, 0, sizeof(m_rawBlob));
+    memcpy(m_rawBlob, blob, m_size * 2);
+#   endif
+
+    return true;
+}
+
+
+bool xmrig::Job::setTarget(const char *target)
+{
+    if (!target) {
+        return false;
+    }
+
+    const size_t len = strlen(target);
+
+    if (len <= 8) {
+        uint32_t tmp = 0;
+        char str[8];
+        memcpy(str, target, len);
+
+        if (!fromHex(str, 8, reinterpret_cast<unsigned char*>(&tmp)) || tmp == 0) {
+            return false;
+        }
+
+        m_target = 0xFFFFFFFFFFFFFFFFULL / (0xFFFFFFFFULL / static_cast<uint64_t>(tmp));
+    }
+    else if (len <= 16) {
+        m_target = 0;
+        char str[16];
+        memcpy(str, target, len);
+
+        if (!fromHex(str, 16, reinterpret_cast<unsigned char*>(&m_target)) || m_target == 0) {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+
+#   ifdef XMRIG_PROXY_PROJECT
+    memset(m_rawTarget, 0, sizeof(m_rawTarget));
+    memcpy(m_rawTarget, target, len);
+#   endif
+
+    m_diff = toDiff(m_target);
+    return true;
+}
+
+
+void xmrig::Job::setAlgorithm(const char *algo)
+{
+    m_algorithm.parseAlgorithm(algo);
+
+    if (m_algorithm.variant() == xmrig::VARIANT_AUTO) {
+        m_algorithm.setVariant(variant());
+    }
+}
+
+
+void xmrig::Job::setHeight(uint64_t height)
+{
+    m_height = height;
+}
+
+
+bool xmrig::Job::fromHex(const char* in, unsigned int len, unsigned char* out)
+{
+    bool error = false;
+    for (unsigned int i = 0; i < len; i += 2) {
+        out[i / 2] = (hf_hex2bin(in[i], error) << 4) | hf_hex2bin(in[i + 1], error);
+
+        if (error) {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void xmrig::Job::toHex(const unsigned char* in, unsigned int len, char* out)
+{
+    for (unsigned int i = 0; i < len; i++) {
+        out[i * 2] = hf_bin2hex((in[i] & 0xF0) >> 4);
+        out[i * 2 + 1] = hf_bin2hex(in[i] & 0x0F);
+    }
+}
+
+
+#ifdef APP_DEBUG
+char *xmrig::Job::toHex(const unsigned char* in, unsigned int len)
+{
+    char *out = new char[len * 2 + 1]();
+    toHex(in, len, out);
+
+    return out;
+}
+#endif
+
+
+xmrig::Variant xmrig::Job::variant() const
+{
+    switch (m_algorithm.algo()) {
+    case CRYPTONIGHT:
+        return (m_blob[0] >= 10) ? VARIANT_4 : ((m_blob[0] >= 8) ? VARIANT_2 : VARIANT_1);
+
+    case CRYPTONIGHT_LITE:
+        return VARIANT_1;
+
+    case CRYPTONIGHT_HEAVY:
+        return VARIANT_0;
+
+    default:
+        break;
+    }
+
+    return m_algorithm.variant();
+}

src/base/net/stratum/Job.h

@@ -0,0 +1,125 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_JOB_H
+#define XMRIG_JOB_H
+
+
+#include <stddef.h>
+#include <stdint.h>
+
+
+#include "common/crypto/Algorithm.h"
+#include "base/net/stratum/Id.h"
+
+
+namespace xmrig {
+
+
+class Job
+{
+public:
+    // Max blob size is 84 (75 fixed + 9 variable), aligned to 96. https://github.com/xmrig/xmrig/issues/1 Thanks fireice-uk.
+    // SECOR increase requirements for blob size: https://github.com/xmrig/xmrig/issues/913
+    static constexpr const size_t kMaxBlobSize = 128;
+
+    Job();
+    Job(int poolId, bool nicehash, const Algorithm &algorithm, const Id &clientId);
+    ~Job();
+
+    bool isEqual(const Job &other) const;
+    bool setBlob(const char *blob);
+    bool setTarget(const char *target);
+    void setAlgorithm(const char *algo);
+    void setHeight(uint64_t height);
+
+    inline bool isNicehash() const                    { return m_nicehash; }
+    inline bool isValid() const                       { return m_size > 0 && m_diff > 0; }
+    inline bool setId(const char *id)                 { return m_id.setId(id); }
+    inline const Algorithm &algorithm() const         { return m_algorithm; }
+    inline const Id &clientId() const                 { return m_clientId; }
+    inline const Id &id() const                       { return m_id; }
+    inline const uint32_t *nonce() const              { return reinterpret_cast<const uint32_t*>(m_blob + 39); }
+    inline const uint8_t *blob() const                { return m_blob; }
+    inline int poolId() const                         { return m_poolId; }
+    inline int threadId() const                       { return m_threadId; }
+    inline size_t size() const                        { return m_size; }
+    inline uint32_t *nonce()                          { return reinterpret_cast<uint32_t*>(m_blob + 39); }
+    inline uint32_t diff() const                      { return static_cast<uint32_t>(m_diff); }
+    inline uint64_t height() const                    { return m_height; }
+    inline uint64_t target() const                    { return m_target; }
+    inline uint8_t fixedByte() const                  { return *(m_blob + 42); }
+    inline void reset()                               { m_size = 0; m_diff = 0; }
+    inline void setClientId(const Id &id)             { m_clientId = id; }
+    inline void setPoolId(int poolId)                 { m_poolId = poolId; }
+    inline void setThreadId(int threadId)             { m_threadId = threadId; }
+    inline void setVariant(const char *variant)       { m_algorithm.parseVariant(variant); }
+    inline void setVariant(int variant)               { m_algorithm.parseVariant(variant); }
+
+#   ifdef XMRIG_PROXY_PROJECT
+    inline char *rawBlob()                 { return m_rawBlob; }
+    inline const char *rawBlob() const     { return m_rawBlob; }
+    inline const char *rawTarget() const   { return m_rawTarget; }
+#   endif
+
+    static bool fromHex(const char* in, unsigned int len, unsigned char* out);
+    static inline uint32_t *nonce(uint8_t *blob)   { return reinterpret_cast<uint32_t*>(blob + 39); }
+    static inline uint64_t toDiff(uint64_t target) { return 0xFFFFFFFFFFFFFFFFULL / target; }
+    static void toHex(const unsigned char* in, unsigned int len, char* out);
+
+#   ifdef APP_DEBUG
+    static char *toHex(const unsigned char* in, unsigned int len);
+#   endif
+
+    inline bool operator==(const Job &other) const { return isEqual(other); }
+    inline bool operator!=(const Job &other) const { return !isEqual(other); }
+
+private:
+    Variant variant() const;
+
+    bool m_autoVariant;
+    bool m_nicehash;
+    int m_poolId;
+    int m_threadId;
+    size_t m_size;
+    uint64_t m_diff;
+    uint64_t m_target;
+    uint8_t m_blob[kMaxBlobSize];
+    uint64_t m_height;
+    xmrig::Algorithm m_algorithm;
+    xmrig::Id m_clientId;
+    xmrig::Id m_id;
+
+#   ifdef XMRIG_PROXY_PROJECT
+    char m_rawBlob[kMaxBlobSize * 2 + 8];
+    char m_rawTarget[24];
+#   endif
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_JOB_H */

src/base/net/stratum/Pool.cpp

@@ -30,7 +30,7 @@
 
 
 #include "base/io/Json.h"
-#include "base/net/Pool.h"
+#include "base/net/stratum/Pool.h"
 #include "rapidjson/document.h"
 
 

src/base/net/stratum/Pools.cpp

@@ -23,10 +23,10 @@
  */
 
 
-#include "base/net/Pools.h"
+#include "base/net/stratum/Pools.h"
+#include "base/net/stratum/strategies/FailoverStrategy.h"
+#include "base/net/stratum/strategies/SinglePoolStrategy.h"
 #include "common/log/Log.h"
-#include "common/net/strategies/FailoverStrategy.h"
-#include "common/net/strategies/SinglePoolStrategy.h"
 #include "rapidjson/document.h"
 
 

src/base/net/stratum/Pools.h

@@ -29,7 +29,7 @@
 #include <vector>
 
 
-#include "base/net/Pool.h"
+#include "base/net/stratum/Pool.h"
 
 
 namespace xmrig {

src/base/net/stratum/SubmitResult.cpp

@@ -0,0 +1,46 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <uv.h>
+
+
+#include "base/net/stratum/SubmitResult.h"
+
+
+xmrig::SubmitResult::SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff, int64_t reqId) :
+    reqId(reqId),
+    seq(seq),
+    diff(diff),
+    actualDiff(actualDiff),
+    elapsed(0)
+{
+    start = uv_hrtime();
+}
+
+
+void xmrig::SubmitResult::done()
+{
+    elapsed = (uv_hrtime() - start) / 1000000;
+}

src/base/net/stratum/SubmitResult.h

@@ -0,0 +1,57 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_SUBMITRESULT_H
+#define XMRIG_SUBMITRESULT_H
+
+
+#include <uv.h>
+
+
+namespace xmrig {
+
+
+class SubmitResult
+{
+public:
+    inline SubmitResult() : reqId(0), seq(0), diff(0), actualDiff(0), elapsed(0), start(0) {}
+    SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff, int64_t reqId = 0);
+
+    void done();
+
+    int64_t reqId;
+    int64_t seq;
+    uint32_t diff;
+    uint64_t actualDiff;
+    uint64_t elapsed;
+
+private:
+    uint64_t start;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_SUBMITRESULT_H */

src/base/net/stratum/Tls.cpp

@@ -0,0 +1,190 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <assert.h>
+
+
+#include "base/net/stratum/Client.h"
+#include "base/net/stratum/Tls.h"
+#include "common/log/Log.h"
+
+
+#ifdef _MSC_VER
+#   define strncasecmp(x,y,z) _strnicmp(x,y,z)
+#endif
+
+
+xmrig::Client::Tls::Tls(Client *client) :
+    m_ready(false),
+    m_buf(),
+    m_fingerprint(),
+    m_client(client),
+    m_ssl(nullptr)
+{
+    m_ctx = SSL_CTX_new(SSLv23_method());
+    assert(m_ctx != nullptr);
+
+    if (!m_ctx) {
+        return;
+    }
+
+    m_writeBio = BIO_new(BIO_s_mem());
+    m_readBio  = BIO_new(BIO_s_mem());
+    SSL_CTX_set_options(m_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
+}
+
+
+xmrig::Client::Tls::~Tls()
+{
+    if (m_ctx) {
+        SSL_CTX_free(m_ctx);
+    }
+
+    if (m_ssl) {
+        SSL_free(m_ssl);
+    }
+}
+
+
+bool xmrig::Client::Tls::handshake()
+{
+    m_ssl = SSL_new(m_ctx);
+    assert(m_ssl != nullptr);
+
+    if (!m_ssl) {
+        return false;
+    }
+
+    SSL_set_connect_state(m_ssl);
+    SSL_set_bio(m_ssl, m_readBio, m_writeBio);
+    SSL_do_handshake(m_ssl);
+
+    return send();
+}
+
+
+bool xmrig::Client::Tls::send(const char *data, size_t size)
+{
+    SSL_write(m_ssl, data, size);
+
+    return send();
+}
+
+
+const char *xmrig::Client::Tls::fingerprint() const
+{
+    return m_ready ? m_fingerprint : nullptr;
+}
+
+
+const char *xmrig::Client::Tls::version() const
+{
+    return m_ready ? SSL_get_version(m_ssl) : nullptr;
+}
+
+
+void xmrig::Client::Tls::read(const char *data, size_t size)
+{
+    BIO_write(m_readBio, data, size);
+
+    if (!SSL_is_init_finished(m_ssl)) {
+        const int rc = SSL_connect(m_ssl);
+
+        if (rc < 0 && SSL_get_error(m_ssl, rc) == SSL_ERROR_WANT_READ) {
+            send();
+        } else if (rc == 1) {
+            X509 *cert = SSL_get_peer_certificate(m_ssl);
+            if (!verify(cert)) {
+                X509_free(cert);
+                m_client->close();
+
+                return;
+            }
+
+            X509_free(cert);
+            m_ready = true;
+            m_client->login();
+      }
+
+      return;
+    }
+
+    int bytes_read = 0;
+    while ((bytes_read = SSL_read(m_ssl, m_buf, sizeof(m_buf))) > 0) {
+        m_client->parse(m_buf, bytes_read);
+    }
+}
+
+
+bool xmrig::Client::Tls::send()
+{
+    return m_client->send(m_writeBio);
+}
+
+
+bool xmrig::Client::Tls::verify(X509 *cert)
+{
+    if (cert == nullptr) {
+        LOG_ERR("[%s] Failed to get server certificate", m_client->m_pool.url());
+
+        return false;
+    }
+
+    if (!verifyFingerprint(cert)) {
+        LOG_ERR("[%s] Failed to verify server certificate fingerprint", m_client->m_pool.url());
+
+        const char *fingerprint = m_client->m_pool.fingerprint();
+        if (strlen(m_fingerprint) == 64 && fingerprint != nullptr) {
+            LOG_ERR("\"%s\" was given", m_fingerprint);
+            LOG_ERR("\"%s\" was configured", fingerprint);
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+
+bool xmrig::Client::Tls::verifyFingerprint(X509 *cert)
+{
+    const EVP_MD *digest = EVP_get_digestbyname("sha256");
+    if (digest == nullptr) {
+        return false;
+    }
+
+    unsigned char md[EVP_MAX_MD_SIZE];
+    unsigned int dlen;
+
+    if (X509_digest(cert, digest, md, &dlen) != 1) {
+        return false;
+    }
+
+    Job::toHex(md, 32, m_fingerprint);
+    const char *fingerprint = m_client->m_pool.fingerprint();
+
+    return fingerprint == nullptr || strncasecmp(m_fingerprint, fingerprint, 64) == 0;
+}

src/base/net/stratum/Tls.h

@@ -0,0 +1,69 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CLIENT_TLS_H
+#define XMRIG_CLIENT_TLS_H
+
+
+#include <openssl/ssl.h>
+
+
+#include "base/net/stratum/Client.h"
+
+
+namespace xmrig {
+
+
+class Client::Tls
+{
+public:
+    Tls(Client *client);
+    ~Tls();
+
+    bool handshake();
+    bool send(const char *data, size_t size);
+    const char *fingerprint() const;
+    const char *version() const;
+    void read(const char *data, size_t size);
+
+private:
+    bool send();
+    bool verify(X509 *cert);
+    bool verifyFingerprint(X509 *cert);
+
+    BIO *m_readBio;
+    BIO *m_writeBio;
+    bool m_ready;
+    char m_buf[1024 * 2];
+    char m_fingerprint[32 * 2 + 8];
+    Client *m_client;
+    SSL *m_ssl;
+    SSL_CTX *m_ctx;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_CLIENT_TLS_H */

src/base/net/stratum/strategies/FailoverStrategy.cpp

@@ -0,0 +1,185 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "base/kernel/interfaces/IStrategyListener.h"
+#include "base/net/stratum/Client.h"
+#include "base/net/stratum/strategies/FailoverStrategy.h"
+#include "common/Platform.h"
+
+
+xmrig::FailoverStrategy::FailoverStrategy(const std::vector<Pool> &pools, int retryPause, int retries, IStrategyListener *listener, bool quiet) :
+    m_quiet(quiet),
+    m_retries(retries),
+    m_retryPause(retryPause),
+    m_active(-1),
+    m_index(0),
+    m_listener(listener)
+{
+    for (const Pool &pool : pools) {
+        add(pool);
+    }
+}
+
+
+xmrig::FailoverStrategy::FailoverStrategy(int retryPause, int retries, IStrategyListener *listener, bool quiet) :
+    m_quiet(quiet),
+    m_retries(retries),
+    m_retryPause(retryPause),
+    m_active(-1),
+    m_index(0),
+    m_listener(listener)
+{
+}
+
+
+xmrig::FailoverStrategy::~FailoverStrategy()
+{
+    for (Client *client : m_pools) {
+        client->deleteLater();
+    }
+}
+
+
+void xmrig::FailoverStrategy::add(const Pool &pool)
+{
+    Client *client = new Client(static_cast<int>(m_pools.size()), Platform::userAgent(), this);
+    client->setPool(pool);
+    client->setRetries(m_retries);
+    client->setRetryPause(m_retryPause * 1000);
+    client->setQuiet(m_quiet);
+
+    m_pools.push_back(client);
+}
+
+
+int64_t xmrig::FailoverStrategy::submit(const JobResult &result)
+{
+    if (m_active == -1) {
+        return -1;
+    }
+
+    return active()->submit(result);
+}
+
+
+void xmrig::FailoverStrategy::connect()
+{
+    m_pools[static_cast<size_t>(m_index)]->connect();
+}
+
+
+void xmrig::FailoverStrategy::resume()
+{
+    if (!isActive()) {
+        return;
+    }
+
+    m_listener->onJob(this, active(), active()->job());
+}
+
+
+void xmrig::FailoverStrategy::setAlgo(const xmrig::Algorithm &algo)
+{
+    for (Client *client : m_pools) {
+        client->setAlgo(algo);
+    }
+}
+
+
+void xmrig::FailoverStrategy::stop()
+{
+    for (size_t i = 0; i < m_pools.size(); ++i) {
+        m_pools[i]->disconnect();
+    }
+
+    m_index  = 0;
+    m_active = -1;
+
+    m_listener->onPause(this);
+}
+
+
+void xmrig::FailoverStrategy::tick(uint64_t now)
+{
+    for (Client *client : m_pools) {
+        client->tick(now);
+    }
+}
+
+
+void xmrig::FailoverStrategy::onClose(Client *client, int failures)
+{
+    if (failures == -1) {
+        return;
+    }
+
+    if (m_active == client->id()) {
+        m_active = -1;
+        m_listener->onPause(this);
+    }
+
+    if (m_index == 0 && failures < m_retries) {
+        return;
+    }
+
+    if (m_index == client->id() && (m_pools.size() - static_cast<size_t>(m_index)) > 1) {
+        m_pools[static_cast<size_t>(++m_index)]->connect();
+    }
+}
+
+
+void xmrig::FailoverStrategy::onJobReceived(Client *client, const Job &job, const rapidjson::Value &)
+{
+    if (m_active == client->id()) {
+        m_listener->onJob(this, client, job);
+    }
+}
+
+
+void xmrig::FailoverStrategy::onLoginSuccess(Client *client)
+{
+    int active = m_active;
+
+    if (client->id() == 0 || !isActive()) {
+        active = client->id();
+    }
+
+    for (size_t i = 1; i < m_pools.size(); ++i) {
+        if (active != static_cast<int>(i)) {
+            m_pools[i]->disconnect();
+        }
+    }
+
+    if (active >= 0 && active != m_active) {
+        m_index = m_active = active;
+        m_listener->onActive(this, client);
+    }
+}
+
+
+void xmrig::FailoverStrategy::onResultAccepted(Client *client, const SubmitResult &result, const char *error)
+{
+    m_listener->onResultAccepted(this, client, result, error);
+}

src/base/net/stratum/strategies/FailoverStrategy.h

@@ -0,0 +1,86 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_FAILOVERSTRATEGY_H
+#define XMRIG_FAILOVERSTRATEGY_H
+
+
+#include <vector>
+
+
+#include "base/kernel/interfaces/IClientListener.h"
+#include "base/kernel/interfaces/IStrategy.h"
+#include "base/net/stratum/Pool.h"
+
+
+namespace xmrig {
+
+
+class Client;
+class IStrategyListener;
+
+
+class FailoverStrategy : public IStrategy, public IClientListener
+{
+public:
+    FailoverStrategy(const std::vector<Pool> &pool, int retryPause, int retries, IStrategyListener *listener, bool quiet = false);
+    FailoverStrategy(int retryPause, int retries, IStrategyListener *listener, bool quiet = false);
+    ~FailoverStrategy() override;
+
+    void add(const Pool &pool);
+
+public:
+    inline bool isActive() const override  { return m_active >= 0; }
+
+    int64_t submit(const JobResult &result) override;
+    void connect() override;
+    void resume() override;
+    void setAlgo(const Algorithm &algo) override;
+    void stop() override;
+    void tick(uint64_t now) override;
+
+protected:
+    inline void onLogin(Client *, rapidjson::Document &, rapidjson::Value &) override {}
+
+    void onClose(Client *client, int failures) override;
+    void onJobReceived(Client *client, const Job &job, const rapidjson::Value &params) override;
+    void onLoginSuccess(Client *client) override;
+    void onResultAccepted(Client *client, const SubmitResult &result, const char *error) override;
+
+private:
+    inline Client *active() const { return m_pools[static_cast<size_t>(m_active)]; }
+
+    const bool m_quiet;
+    const int m_retries;
+    const int m_retryPause;
+    int m_active;
+    int m_index;
+    IStrategyListener *m_listener;
+    std::vector<Client*> m_pools;
+};
+
+
+} /* namespace xmrig */
+
+#endif /* XMRIG_FAILOVERSTRATEGY_H */

src/base/net/stratum/strategies/SinglePoolStrategy.cpp

@@ -0,0 +1,117 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "base/kernel/interfaces/IStrategyListener.h"
+#include "base/net/stratum/Client.h"
+#include "base/net/stratum/strategies/SinglePoolStrategy.h"
+#include "common/Platform.h"
+
+
+xmrig::SinglePoolStrategy::SinglePoolStrategy(const Pool &pool, int retryPause, int retries, IStrategyListener *listener, bool quiet) :
+    m_active(false),
+    m_listener(listener)
+{
+    m_client = new Client(0, Platform::userAgent(), this);
+    m_client->setPool(pool);
+    m_client->setRetries(retries);
+    m_client->setRetryPause(retryPause * 1000);
+    m_client->setQuiet(quiet);
+}
+
+
+xmrig::SinglePoolStrategy::~SinglePoolStrategy()
+{
+    m_client->deleteLater();
+}
+
+
+int64_t xmrig::SinglePoolStrategy::submit(const JobResult &result)
+{
+    return m_client->submit(result);
+}
+
+
+void xmrig::SinglePoolStrategy::connect()
+{
+    m_client->connect();
+}
+
+
+void xmrig::SinglePoolStrategy::resume()
+{
+    if (!isActive()) {
+        return;
+    }
+
+    m_listener->onJob(this, m_client, m_client->job());
+}
+
+
+void xmrig::SinglePoolStrategy::setAlgo(const xmrig::Algorithm &algo)
+{
+    m_client->setAlgo(algo);
+}
+
+
+void xmrig::SinglePoolStrategy::stop()
+{
+    m_client->disconnect();
+}
+
+
+void xmrig::SinglePoolStrategy::tick(uint64_t now)
+{
+    m_client->tick(now);
+}
+
+
+void xmrig::SinglePoolStrategy::onClose(Client *, int)
+{
+    if (!isActive()) {
+        return;
+    }
+
+    m_active = false;
+    m_listener->onPause(this);
+}
+
+
+void xmrig::SinglePoolStrategy::onJobReceived(Client *client, const Job &job, const rapidjson::Value &)
+{
+    m_listener->onJob(this, client, job);
+}
+
+
+void xmrig::SinglePoolStrategy::onLoginSuccess(Client *client)
+{
+    m_active = true;
+    m_listener->onActive(this, client);
+}
+
+
+void xmrig::SinglePoolStrategy::onResultAccepted(Client *client, const SubmitResult &result, const char *error)
+{
+    m_listener->onResultAccepted(this, client, result, error);
+}

src/base/net/stratum/strategies/SinglePoolStrategy.h

@@ -0,0 +1,75 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_SINGLEPOOLSTRATEGY_H
+#define XMRIG_SINGLEPOOLSTRATEGY_H
+
+
+#include "base/kernel/interfaces/IClientListener.h"
+#include "base/kernel/interfaces/IStrategy.h"
+
+
+namespace xmrig {
+
+
+class Client;
+class IStrategyListener;
+class Pool;
+
+
+class SinglePoolStrategy : public IStrategy, public IClientListener
+{
+public:
+    SinglePoolStrategy(const Pool &pool, int retryPause, int retries, IStrategyListener *listener, bool quiet = false);
+    ~SinglePoolStrategy() override;
+
+public:
+    inline bool isActive() const override  { return m_active; }
+
+    int64_t submit(const JobResult &result) override;
+    void connect() override;
+    void resume() override;
+    void setAlgo(const Algorithm &algo) override;
+    void stop() override;
+    void tick(uint64_t now) override;
+
+protected:
+    inline void onLogin(Client *, rapidjson::Document &, rapidjson::Value &) override {}
+
+    void onClose(Client *client, int failures) override;
+    void onJobReceived(Client *client, const Job &job, const rapidjson::Value &params) override;
+    void onLoginSuccess(Client *client) override;
+    void onResultAccepted(Client *client, const SubmitResult &result, const char *error) override;
+
+private:
+    bool m_active;
+    Client *m_client;
+    IStrategyListener *m_listener;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_SINGLEPOOLSTRATEGY_H */

src/base/net/tools/Storage.h

@@ -0,0 +1,97 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_STORAGE_H
+#define XMRIG_STORAGE_H
+
+
+#include <assert.h>
+#include <map>
+
+
+namespace xmrig {
+
+
+template <class TYPE>
+class Storage
+{
+public:
+    inline Storage() :
+        m_counter(0)
+    {
+    }
+
+
+    inline uintptr_t add(TYPE *ptr)
+    {
+        m_data[m_counter] = ptr;
+
+        return m_counter++;
+    }
+
+
+    inline static void *ptr(uintptr_t id) { return reinterpret_cast<void *>(id); }
+
+
+    inline TYPE *get(const void *id) const { return get(reinterpret_cast<uintptr_t>(id)); }
+    inline TYPE *get(uintptr_t id) const
+    {
+        assert(m_data.count(id) > 0);
+        if (m_data.count(id) == 0) {
+            return nullptr;
+        }
+
+        return m_data.at(id);
+    }
+
+
+    inline void remove(const void *id) { delete release(reinterpret_cast<uintptr_t>(id)); }
+    inline void remove(uintptr_t id)   { delete release(id); }
+
+
+    inline TYPE *release(const void *id) { release(reinterpret_cast<uintptr_t>(id)); }
+    inline TYPE *release(uintptr_t id)
+    {
+        TYPE *obj = get(id);
+        if (obj != nullptr) {
+            auto it = m_data.find(id);
+            if (it != m_data.end()) {
+                m_data.erase(it);
+            }
+        }
+
+        return obj;
+    }
+
+
+private:
+    std::map<uintptr_t, TYPE *> m_data;
+    uint64_t m_counter;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_STORAGE_H */