How bitcoin-cli talks to a node

751        + strprintf("> bitcoin-cli -netinfo %d outonly\n\n", NETINFO_MAX_LEVEL) +
752        "Full live dashboard, adjust --interval or --no-title as needed (Linux)\n"
753        + strprintf("> watch --interval 1 --no-title bitcoin-cli -netinfo %d\n\n", NETINFO_MAX_LEVEL) +
754        "See this help\n"
755        "> bitcoin-cli -netinfo help\n"};
756};
757
758/** Process RPC generatetoaddress request. */
759class GenerateToAddressRequestHandler : public BaseRequestHandler
760{
761public:
762    UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override
763    {
764        address_str = args.at(1);
765        UniValue params{RPCConvertValues("generatetoaddress", args)};
766        return JSONRPCRequestObj("generatetoaddress", params, 1);
767    }
768
769    UniValue ProcessReply(const UniValue &reply) override
770    {
771        UniValue result(UniValue::VOBJ);
772        result.pushKV("address", address_str);
773        result.pushKV("blocks", reply.get_obj()["result"]);
774        return JSONRPCReplyObj(std::move(result), NullUniValue, /*id=*/1, JSONRPCVersion::V2);
775    }
776protected:
777    std::string address_str;
778};
779
780/** Process default single requests */
781struct DefaultRequestHandler : BaseRequestHandler {
782    UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override
783    {
784        UniValue params;
785        if(gArgs.GetBoolArg("-named", DEFAULT_NAMED)) {
786            params = RPCConvertNamedValues(method, args);
787        } else {
788            params = RPCConvertValues(method, args);
789        }
790        UniValue id{UniValue::VSTR, gArgs.GetArg("-rpcid", DEFAULT_RPC_REQ_ID)};
791        return JSONRPCRequestObj(method, params, id);
792    }
793
794    UniValue ProcessReply(const UniValue &reply) override
795    {
796        return reply.get_obj();
797    }
798};
799
800static std::optional<UniValue> CallIPC(BaseRequestHandler* rh, const std::string& strMethod, const std::vector<std::string>& args, const std::string& endpoint, const std::string& username)
801{
802    auto ipcconnect{gArgs.GetArg("-ipcconnect", "auto")};
803    if (ipcconnect == "0") return {}; // Do not attempt IPC if -ipcconnect is disabled.
804    if (gArgs.IsArgSet("-rpcconnect") && !gArgs.IsArgNegated("-rpcconnect")) {
805        if (ipcconnect == "auto") return {}; // Use HTTP if -ipcconnect=auto is set and -rpcconnect is enabled.
806        throw std::runtime_error("-rpcconnect and -ipcconnect options cannot both be enabled");
807    }
808
809    std::unique_ptr<interfaces::Init> local_init{interfaces::MakeBasicInit("bitcoin-cli")};
810    if (!local_init || !local_init->ipc()) {
811        if (ipcconnect == "auto") return {}; // Use HTTP if -ipcconnect=auto is set and there is no IPC support.
812        throw std::runtime_error("bitcoin-cli was not built with IPC support");
813    }
814
815    std::unique_ptr<interfaces::Init> node_init;
816    try {
817        node_init = local_init->ipc()->connectAddress(ipcconnect);
818        if (!node_init) return {}; // Fall back to HTTP if -ipcconnect=auto connect failed.
819    } catch (const std::exception& e) {
820        // Catch connect error if -ipcconnect=unix was specified
821        throw CConnectionFailed{strprintf("%s\n\n"
822            "Probably bitcoin-node is not running or not listening on a unix socket. Can be started with:\n\n"
823            "    bitcoin-node -chain=%s -ipcbind=unix", e.what(), gArgs.GetChainTypeString())};
824    }
825
826    std::unique_ptr<interfaces::Rpc> rpc{node_init->makeRpc()};
827    assert(rpc);
828    UniValue request{rh->PrepareRequest(strMethod, args)};
829    UniValue reply{rpc->executeRpc(std::move(request), endpoint, username)};
830    return rh->ProcessReply(reply);
831}
832
833/**
834 * Simple synchronous HTTP client using Sock class.
835 */
836class HTTPClient
837{
838public:
839    static HTTPClient Connect(const std::string& host, uint16_t port, std::chrono::seconds timeout);
840
841    HTTPResponse Post(const std::string& endpoint,
842                      std::span<const std::pair<std::string, std::string>> headers,
843                      const std::string& body);
844
845private:
846    // Signal that the peer closed the connection cleanly. Used in the read-until-close fallback.
847    struct RecvEOF : CConnectionFailed { using CConnectionFailed::CConnectionFailed; };
848
849    std::unique_ptr<Sock> m_socket;
850    std::string m_host;
851    std::chrono::seconds m_timeout;
852
853    HTTPClient(std::unique_ptr<Sock>&& socket, const std::string& host, std::chrono::seconds timeout)
854        : m_socket(std::move(socket)), m_host(host), m_timeout(timeout) {}
855    bool SendRequest(std::string_view request);
856    HTTPResponse ReadResponse();
857    std::optional<std::string> Recv(std::chrono::time_point<std::chrono::steady_clock> deadline);
858};
859
860HTTPClient HTTPClient::Connect(const std::string& host, uint16_t port, std::chrono::seconds timeout)
861{
862    std::vector<CService> services = Lookup(host, port, /*fAllowLookup=*/true, /*nMaxSolutions=*/256);
863    if (services.empty()) {
864        throw CConnectionFailed(strprintf("Could not resolve host: %s", host));
865    }
866
867    const auto deadline{std::chrono::steady_clock::now() + timeout};
868    for (const CService& service : services) {
869        const auto time_left{std::chrono::duration_cast<std::chrono::milliseconds>(deadline - std::chrono::steady_clock::now())};
870        if (time_left.count() <= 0) break;
871
872        auto sock = ConnectDirectly(service, /*manual_connection=*/true, time_left);
873        if (sock) return HTTPClient{std::move(sock), host, timeout};
874    }
875
876    throw CConnectionFailed{"Could not connect to the server"};
877}
878
879HTTPResponse HTTPClient::Post(const std::string& endpoint,
880                              std::span<const std::pair<std::string, std::string>> headers,
881                              const std::string& body)
882{
883    try {
884        // Build HTTP request
885        std::string request = strprintf("POST %s HTTP/1.1\r\n"
886                                        "Host: %s\r\n"
887                                        "Connection: close\r\n"
888                                        "Content-Length: %d\r\n",
889                                        endpoint, m_host, body.size());
890
891        for (const auto& [name, value] : headers) {
892            request += strprintf("%s: %s\r\n", name, value);
893        }
894        request += "\r\n";
895        request += body;
896
897        if (!SendRequest(request)) {
898            throw CConnectionFailed("Failed to send HTTP request");
899        }
900
901        return ReadResponse();
902    } catch (const HTTPError& e) {
903        throw CConnectionFailed(strprintf("HTTP error: %s", e.what()));
904    }
905}
906
907bool HTTPClient::SendRequest(std::string_view request)
908{
909    const auto deadline{std::chrono::steady_clock::now() + m_timeout};
910
911    while (!request.empty()) {
912        Sock::Event event{0};
913        auto time_left = std::chrono::duration_cast<std::chrono::milliseconds>(
914            deadline - std::chrono::steady_clock::now());
915        if (time_left.count() <= 0 || !m_socket->Wait(time_left, Sock::SendEvent, &event)) {
916            return false;
917        }
918
919        if (!(event & Sock::SendEvent)) {
920            continue;
921        }
922
923        ssize_t sent = m_socket->Send(request.data(), request.size(), MSG_NOSIGNAL);
924        if (sent < 0) {
925            int err = WSAGetLastError();
926            if (!IOErrorIsPermanent(err)) {
927                std::this_thread::yield();
928                continue;
929            }
930            return false;
931        }
932        request.remove_prefix(sent);
933    }
934    return true;
935}
936
937HTTPResponse HTTPClient::ReadResponse()
938{
939    HTTPResponse response;
940    std::string buffer;
941    const auto deadline{std::chrono::steady_clock::now() + m_timeout};
942
943    // Read data until we have complete headers
944    size_t headers_end = 0;
945
946    while (headers_end == 0) {
947        if (auto result{Recv(deadline)}) {
948            buffer.append(*result);
949        } else {
950            std::this_thread::yield();
951            continue;
952        }
953
954        // Check for header terminator
955        size_t pos = buffer.find("\r\n\r\n");
956        if (pos != std::string::npos) {
957            headers_end = pos + 4;
958        }
959    }
960
961    // Parse http status
962    util::LineReader reader(std::string_view{buffer.data(), headers_end}, headers_end);
963    auto status_line = reader.ReadLine();
964    if (!status_line) {
965        throw HTTPError{"Failed to read status line"};
966    }
967
968    const std::string_view status_str = *status_line;
969    // Minimum status line is "HTTP/X.Y NNN" (e.g. "HTTP/1.1 200"), 12 characters.
970    if (status_str.size() < 12 || !status_str.starts_with("HTTP/")) {
971        throw HTTPError{"Invalid status line"};
972    }
973
974    size_t space1 = status_str.find(' ');
975    if (space1 == std::string::npos || space1 + 4 > status_str.size()) {
976        throw HTTPError{"Invalid status line format"};
977    }
978
979    const std::string_view status_code_str = status_str.substr(space1 + 1, 3);
980    auto status_code = ToIntegral<int>(status_code_str);
981    if (!status_code) {
982        throw HTTPError{"Invalid status code"};
983    }
984    response.status = *status_code;
985
986    HTTPResponseHeaders headers;
987    headers.Read(reader);
988
989    // Determine body length
990    size_t content_length = 0;
991    bool chunked = false;
992
993    // RFC 9112 §6.3 says responses with both Transfer-Encoding and Content-Length
994    // must be rejected. We are more lenient: Transfer-Encoding takes precedence
995    // and Content-Length is ignored.
996    auto transfer_encoding = headers.FindFirst("transfer-encoding");
997    if (transfer_encoding && ToLower(*transfer_encoding).find("chunked") != std::string::npos) {
998        chunked = true;
999    } else {
1000        auto content_length_header = headers.FindFirst("content-length");