Fix Windows, macOS builds and .deb dependencies

- Guard boost::placeholders with BOOST_VERSION >= 107300 so the code
  compiles with both old (1.59 from depends) and new Boost.
- Switch macOS to depends-based build (like Windows) so it uses
  Boost 1.59 instead of Homebrew's incompatible Boost 1.90.
- Replace hardcoded .deb Depends with dpkg-shlibdeps auto-detection
  so the package installs on any Debian/Ubuntu version.

Author: NateIsern

.github/workflows/release.yml

@@ -74,14 +74,17 @@ jobs:
           # Docs
           cp COPYING README.md doc/GENERATE-KEYS.md $PKG/usr/share/doc/faircoin/
 
+          # Auto-detect shared library dependencies
+          AUTODEPS=$(dpkg-shlibdeps -O $PKG/usr/bin/faircoind $PKG/usr/bin/faircoin-cli $PKG/usr/bin/faircoin-tx 2>/dev/null | sed 's/^shlibs:Depends=//')
+
           # Control file
           cat > $PKG/DEBIAN/control <<EOF
           Package: faircoin
           Version: ${VERSION}
           Section: net
           Priority: optional
           Architecture: amd64
-          Depends: libc6, libssl3, libboost-system1.74.0 | libboost-system1.83.0, libboost-filesystem1.74.0 | libboost-filesystem1.83.0, libboost-thread1.74.0 | libboost-thread1.83.0, libboost-program-options1.74.0 | libboost-program-options1.83.0, libboost-chrono1.74.0 | libboost-chrono1.83.0, libdb5.3++, libminiupnpc17, libevent-2.1-7
+          Depends: ${AUTODEPS}
           Maintainer: FairCoin Official <contact@fairco.in>
           Description: FairCoin cryptocurrency daemon and CLI
            FairCoin is a cryptocurrency with masternodes, coin mixing,

src/faircoin-cli.cpp

@@ -13,6 +13,7 @@
 #include "utilstrencodings.h"
 
 #include <boost/filesystem/operations.hpp>
+#include <boost/version.hpp>
 
 #define _(x) std::string(x) /* Keep the _() around in case gettext or such will be used later to translate non-UI */
 
@@ -108,7 +109,11 @@ Object CallRPC(const string& strMethod, const Array& params)
 
     // Connect to localhost
     bool fUseSSL = GetBoolArg("-rpcssl", false);
+#if BOOST_VERSION >= 108700
+    boost::asio::io_context io_service;
+#else
     asio::io_service io_service;
+#endif
     ssl::context context(ssl::context::sslv23);
     context.set_options(ssl::context::no_sslv2 | ssl::context::no_sslv3);
     asio::ssl::stream<asio::ip::tcp::socket> sslStream(io_service, context);

src/main.cpp

@@ -36,6 +36,7 @@
 #include <boost/filesystem/fstream.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/thread.hpp>
+#include <boost/version.hpp>
 
 using namespace boost;
 using namespace std;
@@ -204,7 +205,9 @@ struct CMainSignals {
 
 void RegisterValidationInterface(CValidationInterface* pwalletIn)
 {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2));
     g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
     g_signals.SetBestChain.connect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
@@ -215,7 +218,9 @@ void RegisterValidationInterface(CValidationInterface* pwalletIn)
 
 void UnregisterValidationInterface(CValidationInterface* pwalletIn)
 {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
     g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn));
     g_signals.Inventory.disconnect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));

src/rpcprotocol.h

@@ -10,6 +10,7 @@
 #include <boost/asio/ssl.hpp>
 #include <boost/iostreams/concepts.hpp>
 #include <boost/iostreams/stream.hpp>
+#include <boost/version.hpp>
 #include <list>
 #include <map>
 #include <stdint.h>
@@ -111,18 +112,27 @@ class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidi
     {
         using namespace boost::asio::ip;
         tcp::resolver resolver(static_cast<boost::asio::io_service&>(stream.get_executor().context()));
+#if BOOST_VERSION >= 108700
+        boost::system::error_code resolve_ec;
+        auto results = resolver.resolve(server, port, resolve_ec);
+        if (resolve_ec)
+            return false;
+        boost::system::error_code error = boost::asio::error::host_not_found;
+        for (const auto& entry : results) {
+            stream.lowest_layer().close();
+            stream.lowest_layer().connect(entry, error);
+            if (!error)
+                break;
+        }
+#else
         tcp::resolver::iterator endpoint_iterator;
 #if BOOST_VERSION >= 104300
         try {
 #endif
-            // The default query (flags address_configured) tries IPv6 if
-            // non-localhost IPv6 configured, and IPv4 if non-localhost IPv4
-            // configured.
             tcp::resolver::query query(server.c_str(), port.c_str());
             endpoint_iterator = resolver.resolve(query);
 #if BOOST_VERSION >= 104300
         } catch (boost::system::system_error& e) {
-            // If we at first don't succeed, try blanket lookup (IPv4+IPv6 independent of configured interfaces)
             tcp::resolver::query query(server.c_str(), port.c_str(), resolver_query_base::flags());
             endpoint_iterator = resolver.resolve(query);
         }
@@ -133,6 +143,7 @@ class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidi
             stream.lowest_layer().close();
             stream.lowest_layer().connect(*endpoint_iterator++, error);
         }
+#endif
         if (error)
             return false;
         return true;

src/rpcserver.cpp

@@ -27,6 +27,11 @@
 #include <boost/iostreams/stream.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
+#include <boost/version.hpp>
+
+#if BOOST_VERSION >= 107300
+using namespace boost::placeholders;
+#endif
 
 using namespace boost;
 using namespace boost::asio;
@@ -41,11 +46,19 @@ static std::string rpcWarmupStatus("RPC server started");
 static CCriticalSection cs_rpcWarmup;
 
 //! These are created by StartRPCThreads, destroyed in StopRPCThreads
+#if BOOST_VERSION >= 108700
+static boost::asio::io_context* rpc_io_service = NULL;
+static map<string, boost::shared_ptr<boost::asio::steady_timer> > deadlineTimers;
+static ssl::context* rpc_ssl_context = NULL;
+static boost::thread_group* rpc_worker_group = NULL;
+static boost::asio::executor_work_guard<boost::asio::io_context::executor_type>* rpc_dummy_work = NULL;
+#else
 static asio::io_service* rpc_io_service = NULL;
 static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
 static ssl::context* rpc_ssl_context = NULL;
 static boost::thread_group* rpc_worker_group = NULL;
 static boost::asio::io_service::work* rpc_dummy_work = NULL;
+#endif
 static std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
 static std::vector<boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
 
@@ -409,8 +422,13 @@ CNetAddr BoostAsioToCNetAddr(boost::asio::ip::address address)
 {
     CNetAddr netaddr;
     // Make sure that IPv4-compatible and IPv4-mapped IPv6 addresses are treated as IPv4 addresses
+#if BOOST_VERSION >= 108700
+    if (address.is_v6() && address.to_v6().is_v4_mapped())
+        address = boost::asio::ip::make_address_v4(boost::asio::ip::v4_mapped, address.to_v6());
+#else
     if (address.is_v6() && (address.to_v6().is_v4_compatible() || address.to_v6().is_v4_mapped()))
         address = address.to_v6().to_v4();
+#endif
 
     if (address.is_v4()) {
         boost::asio::ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
@@ -435,6 +453,16 @@ template <typename Protocol>
 class AcceptedConnectionImpl : public AcceptedConnection
 {
 public:
+#if BOOST_VERSION >= 108700
+    AcceptedConnectionImpl(
+        boost::asio::io_context& io_context,
+        ssl::context& context,
+        bool fUseSSL) : sslStream(io_context, context),
+                        _d(sslStream, fUseSSL),
+                        _stream(_d)
+    {
+    }
+#else
     AcceptedConnectionImpl(
         asio::io_service& io_service,
         ssl::context& context,
@@ -443,6 +471,7 @@ class AcceptedConnectionImpl : public AcceptedConnection
                         _stream(_d)
     {
     }
+#endif
 
     virtual std::iostream& stream()
     {
@@ -486,7 +515,11 @@ static void RPCListen(boost::shared_ptr<basic_socket_acceptor<Protocol, SocketAc
     const bool fUseSSL)
 {
     // Accept connection
+#if BOOST_VERSION >= 108700
+    boost::shared_ptr<AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(*rpc_io_service, context, fUseSSL));
+#else
     boost::shared_ptr<AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(static_cast<boost::asio::io_service&>(acceptor->get_executor().context()), context, fUseSSL));
+#endif
 
     acceptor->async_accept(
         conn->sslStream.lowest_layer(),
@@ -539,7 +572,11 @@ static ip::tcp::endpoint ParseEndpoint(const std::string& strEndpoint, int defau
     std::string addr;
     int port = defaultPort;
     SplitHostPort(strEndpoint, port, addr);
+#if BOOST_VERSION >= 108700
+    return ip::tcp::endpoint(boost::asio::ip::make_address(addr), port);
+#else
     return ip::tcp::endpoint(asio::ip::address::from_string(addr), port);
+#endif
 }
 
 void StartRPCThreads()
@@ -591,7 +628,11 @@ void StartRPCThreads()
     }
 
     assert(rpc_io_service == NULL);
+#if BOOST_VERSION >= 108700
+    rpc_io_service = new boost::asio::io_context();
+#else
     rpc_io_service = new asio::io_service();
+#endif
     rpc_ssl_context = new ssl::context(ssl::context::sslv23);
 
     const bool fUseSSL = GetBoolArg("-rpcssl", false);
@@ -668,7 +709,11 @@ void StartRPCThreads()
                 v6_only_error);
 
             acceptor->bind(endpoint);
+#if BOOST_VERSION >= 108700
+            acceptor->listen(boost::asio::socket_base::max_listen_connections);
+#else
             acceptor->listen(socket_base::max_connections);
+#endif
 
             RPCListen(acceptor, *rpc_ssl_context, fUseSSL);
 
@@ -692,19 +737,30 @@ void StartRPCThreads()
 
     rpc_worker_group = new boost::thread_group();
     for (int i = 0; i < GetArg("-rpcthreads", 4); i++)
+#if BOOST_VERSION >= 108700
+        rpc_worker_group->create_thread(boost::bind(&boost::asio::io_context::run, rpc_io_service));
+#else
         rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
+#endif
     fRPCRunning = true;
 }
 
 void StartDummyRPCThread()
 {
     if (rpc_io_service == NULL) {
+#if BOOST_VERSION >= 108700
+        rpc_io_service = new boost::asio::io_context();
+        rpc_dummy_work = new boost::asio::executor_work_guard<boost::asio::io_context::executor_type>(boost::asio::make_work_guard(*rpc_io_service));
+        rpc_worker_group = new boost::thread_group();
+        rpc_worker_group->create_thread(boost::bind(&boost::asio::io_context::run, rpc_io_service));
+#else
         rpc_io_service = new asio::io_service();
         /* Create dummy "work" to keep the thread from exiting when no timeouts active,
          * see http://www.boost.org/doc/libs/1_51_0/doc/html/boost_asio/reference/io_service.html#boost_asio.reference.io_service.stopping_the_io_service_from_running_out_of_work */
         rpc_dummy_work = new asio::io_service::work(*rpc_io_service);
         rpc_worker_group = new boost::thread_group();
         rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
+#endif
         fRPCRunning = true;
     }
 }
@@ -725,7 +781,11 @@ void StopRPCThreads()
             LogPrintf("%s: Warning: %s when cancelling acceptor", __func__, ec.message());
     }
     rpc_acceptors.clear();
+#if BOOST_VERSION >= 108700
+    BOOST_FOREACH (const PAIRTYPE(std::string, boost::shared_ptr<boost::asio::steady_timer>) & timer, deadlineTimers) {
+#else
     BOOST_FOREACH (const PAIRTYPE(std::string, boost::shared_ptr<deadline_timer>) & timer, deadlineTimers) {
+#endif
         timer.second->cancel(ec);
         if (ec)
             LogPrintf("%s: Warning: %s when cancelling timer", __func__, ec.message());
@@ -783,10 +843,19 @@ void RPCRunLater(const std::string& name, boost::function<void(void)> func, int6
     assert(rpc_io_service != NULL);
 
     if (deadlineTimers.count(name) == 0) {
+#if BOOST_VERSION >= 108700
+        deadlineTimers.insert(make_pair(name,
+            boost::shared_ptr<boost::asio::steady_timer>(new boost::asio::steady_timer(*rpc_io_service))));
+#else
         deadlineTimers.insert(make_pair(name,
             boost::shared_ptr<deadline_timer>(new deadline_timer(*rpc_io_service))));
+#endif
     }
+#if BOOST_VERSION >= 108700
+    deadlineTimers[name]->expires_after(std::chrono::seconds(nSeconds));
+#else
     deadlineTimers[name]->expires_from_now(posix_time::seconds(nSeconds));
+#endif
     deadlineTimers[name]->async_wait(boost::bind(RPCRunHandler, _1, func));
 }
 

src/validationinterface.cpp

@@ -5,6 +5,8 @@
 
 #include "validationinterface.h"
 
+#include <boost/version.hpp>
+
 static CMainSignals g_signals;
 
 CMainSignals& GetMainSignals()
@@ -13,7 +15,9 @@ CMainSignals& GetMainSignals()
 }
 
 void RegisterValidationInterface(CValidationInterface* pwalletIn) {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.UpdatedBlockTip.connect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1));
     g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2));
     g_signals.NotifyTransactionLock.connect(boost::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, _1));
@@ -27,7 +31,9 @@ void RegisterValidationInterface(CValidationInterface* pwalletIn) {
 }
 
 void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
+#if BOOST_VERSION >= 107300
     using namespace boost::placeholders;
+#endif
     g_signals.BlockFound.disconnect(boost::bind(&CValidationInterface::ResetRequestCount, pwalletIn, _1));
     g_signals.ScriptForMining.disconnect(boost::bind(&CValidationInterface::GetScriptForMining, pwalletIn, _1));
     g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));