How bitcoin-cli talks to a node

1001        if (content_length_header) {
1002            auto maybe_len = ToIntegral<size_t>(*content_length_header);
1003            if (!maybe_len) {
1004                throw HTTPError{"Invalid Content-Length"};
1005            }
1006            content_length = *maybe_len;
1007        }
1008    }
1009
1010    // Remove headers data from buffer, so only initial body data remains
1011    buffer.erase(0, headers_end);
1012
1013    // Read remaining body
1014    if (chunked) {
1015        // Handle chunked transfer encoding
1016        std::string body;
1017
1018        while (true) {
1019            // Try to parse a chunk from current buffer
1020            std::string_view chunk_data{buffer};
1021            size_t line_end = chunk_data.find("\r\n");
1022
1023            if (line_end != std::string::npos) {
1024                // Parse chunk size
1025                std::string_view size_str = chunk_data.substr(0, line_end);
1026                // Ignore chunk extensions
1027                size_t semi = size_str.find(';');
1028                if (semi != std::string::npos) {
1029                    size_str = size_str.substr(0, semi);
1030                }
1031
1032                const auto chunk_size{ToIntegral<uint64_t>(util::TrimStringView(size_str), /*base=*/16)};
1033                if (!chunk_size) {
1034                    throw HTTPError{"Invalid chunk size"};
1035                }
1036
1037                if (*chunk_size == 0) {
1038                    // Allow (but ignore) Chunked Trailer section, by
1039                    // reading CRLF-terminated lines until we read an empty line,
1040                    // which indicates the end of this response.
1041                    // See https://httpwg.org/specs/rfc9112.html#rfc.section.7.1.2
1042                    buffer.erase(0, line_end + 2);
1043                    while (true) {
1044                        size_t crlf_pos = buffer.find("\r\n");
1045                        if (crlf_pos == std::string::npos) {
1046                            // Need more data
1047                            if (auto result{Recv(deadline)}) {
1048                                buffer.append(*result);
1049                            } else {
1050                                std::this_thread::yield();
1051                            }
1052                            continue;
1053                        }
1054                        buffer.erase(0, crlf_pos + 2);
1055                        if (crlf_pos == 0) break;
1056                    }
1057                    break;
1058                }
1059
1060                // Check if we have the full chunk
1061                size_t chunk_start = line_end + 2;
1062                if (*chunk_size > std::numeric_limits<size_t>::max() - chunk_start - 2) {
1063                    throw HTTPError{"Chunk size too large"};
1064                }
1065                size_t chunk_end = chunk_start + *chunk_size + 2; // +2 for trailing CRLF
1066
1067                if (buffer.size() >= chunk_end) {
1068                    // Extract chunk data
1069                    body.append(buffer, chunk_start, *chunk_size);
1070
1071                    // Remove processed data
1072                    buffer.erase(0, chunk_end);
1073                    continue;
1074                }
1075            }
1076
1077            // Need more data
1078            while (true) {
1079                if (auto result{Recv(deadline)}) {
1080                    buffer.append(*result);
1081                    break;
1082                } else {
1083                    std::this_thread::yield();
1084                }
1085            }
1086        }
1087
1088        response.body = std::move(body);
1089    } else if (content_length > 0) {
1090        // Fixed content length
1091        while (buffer.size() < content_length) {
1092            if (auto result{Recv(deadline)}) {
1093                buffer.append(*result);
1094            } else {
1095                std::this_thread::yield();
1096            }
1097        }
1098
1099        // Possibly shrink buffer in case we got a larger response than
1100        // originally specified.
1101        buffer.resize(content_length);
1102        response.body = std::move(buffer);
1103    } else {
1104        // No Content-Length and not chunked: read until the peer closes the
1105        // connection (RFC 9112 §6.3, HTTP/1.0 fallback).
1106        try {
1107            while (true) {
1108                if (auto result{Recv(deadline)}) {
1109                    buffer.append(*result);
1110                } else {
1111                    std::this_thread::yield();
1112                }
1113            }
1114        } catch (const RecvEOF&) {}
1115        response.body = std::move(buffer);
1116    }
1117
1118    return response;
1119}
1120
1121std::optional<std::string> HTTPClient::Recv(const std::chrono::time_point<std::chrono::steady_clock> deadline)
1122{
1123    auto wait_for_readable{[this](std::chrono::milliseconds timeout) -> bool {
1124        Sock::Event event{0};
1125        if (!m_socket->Wait(timeout, Sock::RecvEvent, &event)) {
1126            return false;
1127        }
1128        return (event & Sock::RecvEvent) != 0;
1129    }};
1130
1131    auto time_left = std::chrono::duration_cast<std::chrono::milliseconds>(
1132        deadline - std::chrono::steady_clock::now());
1133    if (time_left.count() <= 0 || !wait_for_readable(time_left)) {
1134        throw CConnectionFailed{"timeout"};
1135    }
1136
1137    char recv_buf[4096];
1138    ssize_t nrecv = m_socket->Recv(recv_buf, sizeof(recv_buf), /*flags=*/0);
1139
1140    if (nrecv < 0) {
1141        int err = WSAGetLastError();
1142        if (!IOErrorIsPermanent(err)) {
1143            return std::nullopt;
1144        }
1145        throw CConnectionFailed{strprintf("Read error: %s", NetworkErrorString(err))};
1146    }
1147
1148    if (nrecv == 0) {
1149        throw RecvEOF{"EOF"};
1150    }
1151
1152    return std::string{recv_buf, static_cast<size_t>(nrecv)};
1153}
1154
1155static UniValue CallRPC(BaseRequestHandler* rh, const std::string& strMethod, const std::vector<std::string>& args, const std::string& endpoint, const std::string& username)
1156{
1157    std::string host;
1158    // In preference order, we choose the following for the port:
1159    //     1. -rpcport
1160    //     2. port in -rpcconnect (ie following : in ipv4 or ]: in ipv6)
1161    //     3. default port for chain
1162    uint16_t port{BaseParams().RPCPort()};
1163    {
1164        uint16_t rpcconnect_port{0};
1165        const std::string rpcconnect_str = gArgs.GetArg("-rpcconnect", DEFAULT_RPCCONNECT);
1166        if (!SplitHostPort(rpcconnect_str, rpcconnect_port, host)) {
1167            // Uses argument provided as-is
1168            // (rather than value parsed)
1169            // to aid the user in troubleshooting
1170            throw std::runtime_error(strprintf("Invalid port provided in -rpcconnect: %s", rpcconnect_str));
1171        } else {
1172            if (rpcconnect_port != 0) {
1173                // Use the valid port provided in rpcconnect
1174                port = rpcconnect_port;
1175            } // else, no port was provided in rpcconnect (continue using default one)
1176        }
1177
1178        if (std::optional<std::string> rpcport_arg = gArgs.GetArg("-rpcport")) {
1179            // -rpcport was specified
1180            const uint16_t rpcport_int{ToIntegral<uint16_t>(rpcport_arg.value()).value_or(0)};
1181            if (rpcport_int == 0) {
1182                // Uses argument provided as-is
1183                // (rather than value parsed)
1184                // to aid the user in troubleshooting
1185                throw std::runtime_error(strprintf("Invalid port provided in -rpcport: %s", rpcport_arg.value()));
1186            }
1187
1188            // Use the valid port provided
1189            port = rpcport_int;
1190
1191            // If there was a valid port provided in rpcconnect,
1192            // rpcconnect_port is non-zero.
1193            if (rpcconnect_port != 0) {
1194                tfm::format(std::cerr, "Warning: Port specified in both -rpcconnect and -rpcport. Using -rpcport %u\n", port);
1195            }
1196        }
1197    }
1198
1199    // Set connection timeout
1200    const int timeout = gArgs.GetIntArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT);
1201    std::chrono::seconds timeout_duration;
1202    if (timeout > 0) {
1203        timeout_duration = std::chrono::seconds(timeout);
1204    } else {
1205        // Use 5 year timeout for "indefinite"
1206        timeout_duration = std::chrono::years(5);
1207    }
1208
1209    // Get credentials
1210    std::string rpc_credentials;
1211    std::optional<AuthCookieResult> auth_cookie_result;
1212    if (gArgs.GetArg("-rpcpassword", "") == "") {
1213        // Try fall back to cookie-based authentication if no password is provided
1214        auth_cookie_result = GetAuthCookie(rpc_credentials);
1215    } else {
1216        rpc_credentials = username + ":" + gArgs.GetArg("-rpcpassword", "");
1217    }
1218
1219    const std::pair<std::string, std::string> headers[]{
1220        {"Content-Type", "application/json"},
1221        {"Authorization", "Basic " + EncodeBase64(rpc_credentials)},
1222    };
1223    std::string strRequest = rh->PrepareRequest(strMethod, args).write() + "\n";
1224
1225    HTTPResponse response;
1226    try {
1227        HTTPClient client{HTTPClient::Connect(host, port, timeout_duration)};
1228        response = client.Post(endpoint, headers, strRequest);
1229    } catch (const CConnectionFailed& e) {
1230        const std::string formatted_error{*e.what() ? strprintf(" (%s)", e.what()) : ""};
1231        throw CConnectionFailed(strprintf("Error while attempting to communicate with server %s:%d%s\n\n"
1232                    "Make sure the bitcoind server is running and that you are connecting to the correct RPC port.\n"
1233                    "Use \"bitcoin-cli -help\" for more info.",
1234                    host, port, formatted_error));
1235    }
1236
1237    if (response.status == HTTP_UNAUTHORIZED) {
1238        std::string error{"Authorization failed: "};
1239        if (auth_cookie_result.has_value()) {
1240            switch (*auth_cookie_result) {
1241            case AuthCookieResult::Error:
1242                error += "Failed to read cookie file and no rpcpassword was specified.";
1243                break;
1244            case AuthCookieResult::Disabled:
1245                error += "Cookie file was disabled via -norpccookiefile and no rpcpassword was specified.";
1246                break;
1247            case AuthCookieResult::Ok:
1248                error += "Cookie file credentials were invalid and no rpcpassword was specified.";
1249                break;
1250            }