Removed IConfigCreator/ConfigCreator and changed file structure.

src/core/config/Config.cpp

@@ -0,0 +1,372 @@
+/* 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 <string.h>
+#include <uv.h>
+#include <inttypes.h>
+
+
+#include "base/io/log/Log.h"
+#include "common/config/ConfigLoader.h"
+#include "common/cpu/Cpu.h"
+#include "core/config/Config.h"
+#include "crypto/Asm.h"
+#include "crypto/CryptoNight_constants.h"
+#include "rapidjson/document.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/prettywriter.h"
+#include "workers/CpuThread.h"
+
+
+static char affinity_tmp[20] = { 0 };
+
+
+xmrig::Config::Config() : xmrig::CommonConfig(),
+    m_aesMode(AES_AUTO),
+    m_algoVariant(AV_AUTO),
+    m_assembly(ASM_AUTO),
+    m_hugePages(true),
+    m_safe(false),
+    m_shouldSave(false),
+    m_maxCpuUsage(100),
+    m_priority(-1)
+{
+}
+
+
+bool xmrig::Config::reload(const char *json)
+{
+    return xmrig::ConfigLoader::reload(this, json);
+}
+
+
+void xmrig::Config::getJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+
+    doc.SetObject();
+
+    auto &allocator = doc.GetAllocator();
+
+    doc.AddMember("algo", StringRef(algorithm().name()), allocator);
+
+    Value api(kObjectType);
+    api.AddMember("id",           m_apiId.toJSON(), allocator);
+    api.AddMember("worker-id",    m_apiWorkerId.toJSON(), allocator);
+    doc.AddMember("api",          api, allocator);
+    doc.AddMember("http",         m_http.toJSON(doc), allocator);
+
+#   ifndef XMRIG_NO_ASM
+    doc.AddMember("asm",          Asm::toJSON(m_assembly), allocator);
+#   endif
+
+    doc.AddMember("autosave",     isAutoSave(), allocator);
+    doc.AddMember("av",           algoVariant(), allocator);
+    doc.AddMember("background",   isBackground(), allocator);
+    doc.AddMember("colors",       Log::colors, allocator);
+
+    if (affinity() != -1L) {
+        snprintf(affinity_tmp, sizeof(affinity_tmp) - 1, "0x%" PRIX64, affinity());
+        doc.AddMember("cpu-affinity", StringRef(affinity_tmp), allocator);
+    }
+    else {
+        doc.AddMember("cpu-affinity", kNullType, allocator);
+    }
+
+    doc.AddMember("cpu-priority",      priority() != -1 ? Value(priority()) : Value(kNullType), allocator);
+    doc.AddMember("donate-level",      m_pools.donateLevel(), allocator);
+    doc.AddMember("donate-over-proxy", m_pools.proxyDonate(), allocator);
+    doc.AddMember("huge-pages",        isHugePages(), allocator);
+    doc.AddMember("hw-aes",            m_aesMode == AES_AUTO ? Value(kNullType) : Value(m_aesMode == AES_HW), allocator);
+    doc.AddMember("log-file",          m_logFile.toJSON(), allocator);
+    doc.AddMember("max-cpu-usage",     m_maxCpuUsage, allocator);
+    doc.AddMember("pools",             m_pools.toJSON(doc), allocator);
+    doc.AddMember("print-time",        printTime(), allocator);
+    doc.AddMember("retries",           m_pools.retries(), allocator);
+    doc.AddMember("retry-pause",       m_pools.retryPause(), allocator);
+    doc.AddMember("safe",              m_safe, allocator);
+
+    if (threadsMode() != Simple) {
+        Value threads(kArrayType);
+
+        for (const IThread *thread : m_threads.list) {
+            threads.PushBack(thread->toConfig(doc), allocator);
+        }
+
+        doc.AddMember("threads", threads, allocator);
+    }
+    else {
+        doc.AddMember("threads", threadsCount(), allocator);
+    }
+
+    doc.AddMember("user-agent", m_userAgent.toJSON(), allocator);
+    doc.AddMember("syslog",     isSyslog(), allocator);
+    doc.AddMember("watch",      m_watch, allocator);
+}
+
+
+xmrig::Config *xmrig::Config::load(Process *process, IConfigListener *listener)
+{
+    return static_cast<Config*>(ConfigLoader::load(process, listener));
+}
+
+
+bool xmrig::Config::finalize()
+{
+    if (m_state != NoneState) {
+        return CommonConfig::finalize();
+    }
+
+    if (!CommonConfig::finalize()) {
+        return false;
+    }
+
+    if (!m_threads.cpu.empty()) {
+        m_threads.mode     = Advanced;
+        const bool softAES = (m_aesMode == AES_AUTO ? (Cpu::info()->hasAES() ? AES_HW : AES_SOFT) : m_aesMode) == AES_SOFT;
+
+        for (size_t i = 0; i < m_threads.cpu.size(); ++i) {
+            m_threads.list.push_back(CpuThread::createFromData(i, m_algorithm.algo(), m_threads.cpu[i], m_priority, softAES));
+        }
+
+        return true;
+    }
+
+    const AlgoVariant av = getAlgoVariant();   
+    m_threads.mode = m_threads.count ? Simple : Automatic;
+
+    const size_t size = CpuThread::multiway(av) * cn_select_memory(m_algorithm.algo()) / 1024;
+
+    if (!m_threads.count) {
+        m_threads.count = Cpu::info()->optimalThreadsCount(size, m_maxCpuUsage);
+    }
+    else if (m_safe) {
+        const size_t count = Cpu::info()->optimalThreadsCount(size, m_maxCpuUsage);
+        if (m_threads.count > count) {
+            m_threads.count = count;
+        }
+    }
+
+    for (size_t i = 0; i < m_threads.count; ++i) {
+        m_threads.list.push_back(CpuThread::createFromAV(i, m_algorithm.algo(), av, m_threads.mask, m_priority, m_assembly));
+    }
+
+    m_shouldSave = m_threads.mode == Automatic;
+    return true;
+}
+
+
+bool xmrig::Config::parseBoolean(int key, bool enable)
+{
+    if (!CommonConfig::parseBoolean(key, enable)) {
+        return false;
+    }
+
+    switch (key) {
+    case SafeKey: /* --safe */
+        m_safe = enable;
+        break;
+
+    case HugePagesKey: /* --no-huge-pages */
+        m_hugePages = enable;
+        break;
+
+    case HardwareAESKey: /* hw-aes config only */
+        m_aesMode = enable ? AES_HW : AES_SOFT;
+        break;
+
+#   ifndef XMRIG_NO_ASM
+    case AssemblyKey:
+        m_assembly = Asm::parse(enable);
+        break;
+#   endif
+
+    default:
+        break;
+    }
+
+    return true;
+}
+
+
+bool xmrig::Config::parseString(int key, const char *arg)
+{
+    if (!CommonConfig::parseString(key, arg)) {
+        return false;
+    }
+
+    switch (key) {
+    case AVKey:          /* --av */
+    case MaxCPUUsageKey: /* --max-cpu-usage */
+    case CPUPriorityKey: /* --cpu-priority */
+        return parseUint64(key, strtol(arg, nullptr, 10));
+
+    case SafeKey: /* --safe */
+        return parseBoolean(key, true);
+
+    case HugePagesKey: /* --no-huge-pages */
+        return parseBoolean(key, false);
+
+    case ThreadsKey:  /* --threads */
+        if (strncmp(arg, "all", 3) == 0) {
+            m_threads.count = Cpu::info()->threads();
+            return true;
+        }
+
+        return parseUint64(key, strtol(arg, nullptr, 10));
+
+    case CPUAffinityKey: /* --cpu-affinity */
+        {
+            const char *p  = strstr(arg, "0x");
+            return parseUint64(key, p ? strtoull(p, nullptr, 16) : strtoull(arg, nullptr, 10));
+        }
+
+#   ifndef XMRIG_NO_ASM
+    case AssemblyKey: /* --asm */
+        m_assembly = Asm::parse(arg);
+        break;
+#   endif
+
+    default:
+        break;
+    }
+
+    return true;
+}
+
+
+bool xmrig::Config::parseUint64(int key, uint64_t arg)
+{
+    if (!CommonConfig::parseUint64(key, arg)) {
+        return false;
+    }
+
+    switch (key) {
+    case CPUAffinityKey: /* --cpu-affinity */
+        if (arg) {
+            m_threads.mask = static_cast<int64_t>(arg);
+        }
+        break;
+
+    default:
+        return parseInt(key, static_cast<int>(arg));
+    }
+
+    return true;
+}
+
+
+void xmrig::Config::parseJSON(const rapidjson::Document &doc)
+{
+    CommonConfig::parseJSON(doc);
+
+    const rapidjson::Value &threads = doc["threads"];
+
+    if (threads.IsArray()) {
+        for (const rapidjson::Value &value : threads.GetArray()) {
+            if (!value.IsObject()) {
+                continue;
+            }
+
+            if (value.HasMember("low_power_mode")) {
+                auto data = CpuThread::parse(value);
+
+                if (data.valid) {
+                    m_threads.cpu.push_back(std::move(data));
+                }
+            }
+        }
+    }
+}
+
+
+bool xmrig::Config::parseInt(int key, int arg)
+{
+    switch (key) {
+    case ThreadsKey: /* --threads */
+        if (arg >= 0 && arg < 1024) {
+            m_threads.count = arg;
+        }
+        break;
+
+    case AVKey: /* --av */
+        if (arg >= AV_AUTO && arg < AV_MAX) {
+            m_algoVariant = static_cast<AlgoVariant>(arg);
+        }
+        break;
+
+    case MaxCPUUsageKey: /* --max-cpu-usage */
+        if (m_maxCpuUsage > 0 && arg <= 100) {
+            m_maxCpuUsage = arg;
+        }
+        break;
+
+    case CPUPriorityKey: /* --cpu-priority */
+        if (arg >= 0 && arg <= 5) {
+            m_priority = arg;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return true;
+}
+
+
+xmrig::AlgoVariant xmrig::Config::getAlgoVariant() const
+{
+#   ifndef XMRIG_NO_AEON
+    if (m_algorithm.algo() == xmrig::CRYPTONIGHT_LITE) {
+        return getAlgoVariantLite();
+    }
+#   endif
+
+    if (m_algoVariant <= AV_AUTO || m_algoVariant >= AV_MAX) {
+        return Cpu::info()->hasAES() ? AV_SINGLE : AV_SINGLE_SOFT;
+    }
+
+    if (m_safe && !Cpu::info()->hasAES() && m_algoVariant <= AV_DOUBLE) {
+        return static_cast<AlgoVariant>(m_algoVariant + 2);
+    }
+
+    return m_algoVariant;
+}
+
+
+#ifndef XMRIG_NO_AEON
+xmrig::AlgoVariant xmrig::Config::getAlgoVariantLite() const
+{
+    if (m_algoVariant <= AV_AUTO || m_algoVariant >= AV_MAX) {
+        return Cpu::info()->hasAES() ? AV_DOUBLE : AV_DOUBLE_SOFT;
+    }
+
+    if (m_safe && !Cpu::info()->hasAES() && m_algoVariant <= AV_DOUBLE) {
+        return static_cast<AlgoVariant>(m_algoVariant + 2);
+    }
+
+    return m_algoVariant;
+}
+#endif

src/core/config/Config.h

@@ -0,0 +1,130 @@
+/* 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-2018 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_CONFIG_H
+#define XMRIG_CONFIG_H
+
+
+#include <stdint.h>
+#include <vector>
+
+
+#include "common/config/CommonConfig.h"
+#include "common/xmrig.h"
+#include "rapidjson/fwd.h"
+#include "workers/CpuThread.h"
+
+
+namespace xmrig {
+
+
+class ConfigLoader;
+class IThread;
+class IConfigListener;
+class Process;
+
+
+/**
+ * @brief The Config class
+ *
+ * Options with dynamic reload:
+ *   colors
+ *   debug
+ *   verbose
+ *   custom-diff (only for new connections)
+ *   api/worker-id
+ *   pools/
+ */
+class Config : public CommonConfig
+{
+public:
+    enum ThreadsMode {
+        Automatic,
+        Simple,
+        Advanced
+    };
+
+
+    Config();
+
+    bool reload(const char *json);
+
+    void getJSON(rapidjson::Document &doc) const override;
+
+    inline AesMode aesMode() const                       { return m_aesMode; }
+    inline AlgoVariant algoVariant() const               { return m_algoVariant; }
+    inline Assembly assembly() const                     { return m_assembly; }
+    inline bool isHugePages() const                      { return m_hugePages; }
+    inline bool isShouldSave() const                     { return (m_shouldSave || m_upgrade) && isAutoSave(); }
+    inline const std::vector<IThread *> &threads() const { return m_threads.list; }
+    inline int priority() const                          { return m_priority; }
+    inline int threadsCount() const                      { return static_cast<int>(m_threads.list.size()); }
+    inline int64_t affinity() const                      { return m_threads.mask; }
+    inline static IConfig *create()                      { return new Config(); }
+    inline ThreadsMode threadsMode() const               { return m_threads.mode; }
+
+    static Config *load(Process *process, IConfigListener *listener);
+
+protected:
+    bool finalize() override;
+    bool parseBoolean(int key, bool enable) override;
+    bool parseString(int key, const char *arg) override;
+    bool parseUint64(int key, uint64_t arg) override;
+    void parseJSON(const rapidjson::Document &doc) override;
+
+private:
+    bool parseInt(int key, int arg);
+
+    AlgoVariant getAlgoVariant() const;
+#   ifndef XMRIG_NO_AEON
+    AlgoVariant getAlgoVariantLite() const;
+#   endif
+
+
+    struct Threads
+    {
+       inline Threads() : mask(-1L), count(0), mode(Automatic) {}
+
+       int64_t mask;
+       size_t count;
+       std::vector<CpuThread::Data> cpu;
+       std::vector<IThread *> list;
+       ThreadsMode mode;
+    };
+
+
+    AesMode m_aesMode;
+    AlgoVariant m_algoVariant;
+    Assembly m_assembly;
+    bool m_hugePages;
+    bool m_safe;
+    bool m_shouldSave;
+    int m_maxCpuUsage;
+    int m_priority;
+    Threads m_threads;
+};
+
+
+} /* namespace xmrig */
+
+#endif /* XMRIG_CONFIG_H */

src/core/config/ConfigLoader_default.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_CONFIGLOADER_DEFAULT_H
+#define XMRIG_CONFIGLOADER_DEFAULT_H
+
+
+namespace xmrig {
+
+
+#ifdef XMRIG_FEATURE_EMBEDDED_CONFIG
+const static char *default_config =
+R"===(
+{
+    "algo": "cryptonight",
+    "api": {
+        "port": 0,
+        "access-token": null,
+        "id": null,
+        "worker-id": null,
+        "ipv6": false,
+        "restricted": true
+    },
+    "asm": true,
+    "autosave": true,
+    "av": 0,
+    "background": false,
+    "colors": true,
+    "cpu-affinity": null,
+    "cpu-priority": null,
+    "donate-level": 5,
+    "donate-over-proxy": 1,
+    "huge-pages": true,
+    "hw-aes": null,
+    "log-file": null,
+    "max-cpu-usage": 100,
+    "pools": [
+        {
+            "url": "donate.v2.xmrig.com:3333",
+            "user": "YOUR_WALLET_ADDRESS",
+            "pass": "x",
+            "rig-id": null,
+            "nicehash": false,
+            "keepalive": false,
+            "variant": -1,
+            "tls": false,
+            "tls-fingerprint": null
+        }
+    ],
+    "print-time": 60,
+    "retries": 5,
+    "retry-pause": 5,
+    "safe": false,
+    "threads": null,
+    "user-agent": null,
+    "syslog": false,
+    "watch": true
+}
+)===";
+#endif
+
+
+} /* namespace xmrig */
+
+#endif /* XMRIG_CONFIGLOADER_DEFAULT_H */

src/core/config/ConfigLoader_platform.h

@@ -0,0 +1,135 @@
+/* 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_CONFIGLOADER_PLATFORM_H
+#define XMRIG_CONFIGLOADER_PLATFORM_H
+
+
+#ifdef _MSC_VER
+#   include "getopt/getopt.h"
+#else
+#   include <getopt.h>
+#endif
+
+
+#include "common/interfaces/IConfig.h"
+#include "version.h"
+
+
+namespace xmrig {
+
+
+static char const short_options[] = "a:c:kBp:Px:r:R:s:t:T:o:u:O:v:l:S";
+
+
+static struct option const options[] = {
+    { "algo",                  1, nullptr, IConfig::AlgorithmKey          },
+    { "api-worker-id",         1, nullptr, IConfig::ApiWorkerIdKey        },
+    { "api-id",                1, nullptr, IConfig::ApiIdKey              },
+    { "http-enabled",          0, nullptr, IConfig::HttpEnabledKey        },
+    { "http-host",             1, nullptr, IConfig::HttpHostKey           },
+    { "http-access-token",     1, nullptr, IConfig::HttpAccessTokenKey    },
+    { "http-port",             1, nullptr, IConfig::HttpPort              },
+    { "http-no-restricted",    0, nullptr, IConfig::HttpRestrictedKey     },
+    { "av",                    1, nullptr, IConfig::AVKey                 },
+    { "background",            0, nullptr, IConfig::BackgroundKey         },
+    { "config",                1, nullptr, IConfig::ConfigKey             },
+    { "cpu-affinity",          1, nullptr, IConfig::CPUAffinityKey        },
+    { "cpu-priority",          1, nullptr, IConfig::CPUPriorityKey        },
+    { "donate-level",          1, nullptr, IConfig::DonateLevelKey        },
+    { "donate-over-proxy",     1, nullptr, IConfig::ProxyDonateKey        },
+    { "dry-run",               0, nullptr, IConfig::DryRunKey             },
+    { "keepalive",             0, nullptr, IConfig::KeepAliveKey          },
+    { "log-file",              1, nullptr, IConfig::LogFileKey            },
+    { "max-cpu-usage",         1, nullptr, IConfig::MaxCPUUsageKey        },
+    { "nicehash",              0, nullptr, IConfig::NicehashKey           },
+    { "no-color",              0, nullptr, IConfig::ColorKey              },
+    { "no-watch",              0, nullptr, IConfig::WatchKey              },
+    { "no-huge-pages",         0, nullptr, IConfig::HugePagesKey          },
+    { "variant",               1, nullptr, IConfig::VariantKey            },
+    { "pass",                  1, nullptr, IConfig::PasswordKey           },
+    { "print-time",            1, nullptr, IConfig::PrintTimeKey          },
+    { "retries",               1, nullptr, IConfig::RetriesKey            },
+    { "retry-pause",           1, nullptr, IConfig::RetryPauseKey         },
+    { "safe",                  0, nullptr, IConfig::SafeKey               },
+    { "syslog",                0, nullptr, IConfig::SyslogKey             },
+    { "threads",               1, nullptr, IConfig::ThreadsKey            },
+    { "url",                   1, nullptr, IConfig::UrlKey                },
+    { "user",                  1, nullptr, IConfig::UserKey               },
+    { "user-agent",            1, nullptr, IConfig::UserAgentKey          },
+    { "userpass",              1, nullptr, IConfig::UserpassKey           },
+    { "rig-id",                1, nullptr, IConfig::RigIdKey              },
+    { "tls",                   0, nullptr, IConfig::TlsKey                },
+    { "tls-fingerprint",       1, nullptr, IConfig::FingerprintKey        },
+    { "asm",                   1, nullptr, IConfig::AssemblyKey           },
+
+#   ifdef XMRIG_DEPRECATED
+    { "api-port",              1, nullptr, IConfig::ApiPort               },
+    { "api-access-token",      1, nullptr, IConfig::ApiAccessTokenKey     },
+    { "api-no-restricted",     0, nullptr, IConfig::ApiRestrictedKey      },
+    { "api-ipv6",              0, nullptr, IConfig::ApiIPv6Key            },
+#   endif
+
+    { nullptr,                 0, nullptr, 0 }
+};
+
+
+static struct option const config_options[] = {
+    { "algo",              1, nullptr, IConfig::AlgorithmKey   },
+    { "av",                1, nullptr, IConfig::AVKey          },
+    { "background",        0, nullptr, IConfig::BackgroundKey  },
+    { "colors",            0, nullptr, IConfig::ColorKey       },
+    { "cpu-affinity",      1, nullptr, IConfig::CPUAffinityKey },
+    { "cpu-priority",      1, nullptr, IConfig::CPUPriorityKey },
+    { "donate-level",      1, nullptr, IConfig::DonateLevelKey },
+    { "donate-over-proxy", 1, nullptr, IConfig::ProxyDonateKey },
+    { "dry-run",           0, nullptr, IConfig::DryRunKey      },
+    { "huge-pages",        0, nullptr, IConfig::HugePagesKey   },
+    { "log-file",          1, nullptr, IConfig::LogFileKey     },
+    { "max-cpu-usage",     1, nullptr, IConfig::MaxCPUUsageKey },
+    { "print-time",        1, nullptr, IConfig::PrintTimeKey   },
+    { "retries",           1, nullptr, IConfig::RetriesKey     },
+    { "retry-pause",       1, nullptr, IConfig::RetryPauseKey  },
+    { "safe",              0, nullptr, IConfig::SafeKey        },
+    { "syslog",            0, nullptr, IConfig::SyslogKey      },
+    { "threads",           1, nullptr, IConfig::ThreadsKey     },
+    { "user-agent",        1, nullptr, IConfig::UserAgentKey   },
+    { "watch",             0, nullptr, IConfig::WatchKey       },
+    { "hw-aes",            0, nullptr, IConfig::HardwareAESKey },
+    { "asm",               1, nullptr, IConfig::AssemblyKey    },
+    { "autosave",          0, nullptr, IConfig::AutoSaveKey    },
+    { nullptr,             0, nullptr, 0 }
+};
+
+
+static struct option const api_options[] = {
+    { "worker-id",     1, nullptr, IConfig::ApiWorkerIdKey    },
+    { "id",            1, nullptr, IConfig::ApiIdKey          },
+    { nullptr,         0, nullptr, 0 }
+};
+
+
+} /* namespace xmrig */
+
+#endif /* XMRIG_CONFIGLOADER_PLATFORM_H */

src/core/config/usage.h

@@ -0,0 +1,96 @@
+/* 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_USAGE_H
+#define XMRIG_USAGE_H
+
+
+#include "version.h"
+
+
+namespace xmrig {
+
+
+static char const usage[] = "\
+Usage: " APP_ID " [OPTIONS]\n\
+Options:\n\
+  -a, --algo=ALGO           specify the algorithm to use\n\
+                              cryptonight\n"
+#ifndef XMRIG_NO_AEON
+"\
+                              cryptonight-lite\n"
+#endif
+#ifndef XMRIG_NO_SUMO
+"\
+                              cryptonight-heavy\n"
+#endif
+"\
+  -o, --url=URL             URL of mining server\n\
+  -O, --userpass=U:P        username:password pair for mining server\n\
+  -u, --user=USERNAME       username for mining server\n\
+  -p, --pass=PASSWORD       password for mining server\n\
+      --rig-id=ID           rig identifier for pool-side statistics (needs pool support)\n\
+  -t, --threads=N           number of miner threads\n\
+  -v, --av=N                algorithm variation, 0 auto select\n\
+  -k, --keepalive           send keepalived packet for prevent timeout (needs pool support)\n\
+      --nicehash            enable nicehash.com support\n\
+      --tls                 enable SSL/TLS support (needs pool support)\n\
+      --tls-fingerprint=F   pool TLS certificate fingerprint, if set enable strict certificate pinning\n\
+  -r, --retries=N           number of times to retry before switch to backup server (default: 5)\n\
+  -R, --retry-pause=N       time to pause between retries (default: 5)\n\
+      --cpu-affinity        set process affinity to CPU core(s), mask 0x3 for cores 0 and 1\n\
+      --cpu-priority        set process priority (0 idle, 2 normal to 5 highest)\n\
+      --no-huge-pages       disable huge pages support\n\
+      --no-color            disable colored output\n\
+      --variant             algorithm PoW variant\n\
+      --donate-level=N      donate level, default 5%% (5 minutes in 100 minutes)\n\
+      --user-agent          set custom user-agent string for pool\n\
+  -B, --background          run the miner in the background\n\
+  -c, --config=FILE         load a JSON-format configuration file\n\
+  -l, --log-file=FILE       log all output to a file\n"
+# ifdef HAVE_SYSLOG_H
+"\
+  -S, --syslog              use system log for output messages\n"
+# endif
+"\
+      --max-cpu-usage=N     maximum CPU usage for automatic threads mode (default 75)\n\
+      --safe                safe adjust threads and av settings for current CPU\n\
+      --asm=ASM             ASM code for cn/2, possible values: auto, none, intel, ryzen, bulldozer.\n\
+      --print-time=N        print hashrate report every N seconds\n\
+      --api-worker-id=ID    custom worker-id for API\n\
+      --api-id=ID           custom instance ID for API\n\
+      --http-enabled        enable HTTP API\n\
+      --http-host=HOST      bind host for HTTP API (by default 127.0.0.1)\n\
+      --http-port=N         bind port for HTTP API\n\
+      --http-access-token=T access token for HTTP API\n\
+      --http-no-restricted  enable full remote access to HTTP API (only if access token set)\n\
+      --dry-run             test configuration and exit\n\
+  -h, --help                display this help and exit\n\
+  -V, --version             output version information and exit\n\
+";
+
+
+} /* namespace xmrig */
+
+#endif /* XMRIG_USAGE_H */