libbitcoin / libbitcoin-network / 41461354711

/**

 * Copyright (c) 2011-2026 libbitcoin developers

 *

 * This file is part of libbitcoin.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero 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 Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <bitcoin/network/error.hpp>

#include <bitcoin/network/define.hpp>

#include <bitcoin/network/tls/constants.hpp>

namespace libbitcoin {

namespace network {

namespace error {

BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)

DEFINE_ERROR_T_MESSAGE_MAP(error)

{

    { success, "success" },

    { unknown, "unknown error" },

    { upgrade, "upgrade requested" },

    { upgraded, "upgraded" },

    // addresses

    { address_invalid, "address invalid" },

    { address_not_found, "address not found" },

    { address_disabled, "address protocol disabled" },

    { address_unsupported, "advertised services unsupported" },

    { address_insufficient, "advertised services insufficient" },

    { seeding_unsuccessful, "seeding unsuccessful" },

    { seeding_complete, "seeding complete" },

    // file system

    { file_load, "failed to load file" },

    { file_save, "failed to save file" },

    { file_system, "file system error" },

    { file_exception, "file exception" },

    // general I/O failures

    { bad_stream, "bad data stream" },

    { not_allowed, "not allowed" },

    { peer_disconnect, "peer disconnect" },

    { peer_unsupported, "peer unsupported" },

    { peer_insufficient, "peer insufficient" },

    { peer_timestamp, "peer timestamp" },

    { protocol_violation, "protocol violation" },

    { channel_overflow, "channel overflow" },

    { channel_underflow, "channel underflow" },

    { channel_backlog, "channel write backlog" },

    { message_dropped, "message dropped" },

    // incoming connection failures

    { listen_failed, "incoming connection failed" },

    { accept_failed, "connection to self aborted" },

    { oversubscribed, "service oversubscribed" },

    // incoming/outgoing connection failures

    { address_blocked, "address blocked by policy" },

    // outgoing connection failures

    { address_in_use, "address already in use" },

    { resolve_failed, "resolving hostname failed" },

    { connect_failed, "unable to reach remote host" },

    { net_unreachable, "network unreachable" },

    { host_unreachable, "host unreachable" },

    { connection_refused, "connection refused" },

    // heading read failures

    { invalid_heading, "invalid message heading" },

    { invalid_magic, "invalid message heading magic" },

    // payload read failures

    { oversized_payload, "oversize message payload" },

    { invalid_checksum, "invalid message checksum" },

    { invalid_message, "message failed to deserialize" },

    { unknown_message, "unknown message type" },

    // general failures

    { invalid_configuration, "invalid configuration" },

    { insufficient_buffer, "insufficient buffer space" },

    { operation_timeout, "operation timed out" },

    { operation_canceled, "operation canceled" },

    { operation_failed, "operation failed" },

    // termination

    { channel_timeout, "channel timed out" },

    { channel_conflict, "channel conflict" },

    { channel_dropped, "channel dropped" },

    { channel_expired, "channel expired" },

    { channel_inactive, "channel inactive" },

    { channel_stopped, "channel stopped" },

    { service_stopped, "service stopped" },

    { service_suspended, "service suspended" },

    { subscriber_exists, "subscriber exists" },

    { subscriber_stopped, "subscriber stopped" },

    { desubscribed, "subscriber desubscribed" },

    // socks5

    { socks_method, "socks method not supported" },

    { socks_username, "socks username too long" },

    { socks_password, "socks password too long" },

    { socks_host_name, "socks host name too long" },

    { socks_authentication, "socks authentication failed" },

    { socks_failure, "socks failure" },

    { socks_disallowed, "socks connection disallowed" },

    { socks_net_unreachable, "socks network unreachable" },

    { socks_host_unreachable, "socks host unreachable" },

    { socks_connection_refused, "socks connection refused" },

    { socks_connection_expired, "socks connection expired" },

    { socks_unsupported_command, "socks unsupported command" },

    { socks_unsupported_address, "socks unsupported address" },

    { socks_unassigned_failure, "socks unassigned failure" },

    { socks_response_invalid, "socks response invalid" },

    // sam

    { sam_response_invalid, "sam response invalid" },

    { sam_no_version, "sam version not supported" },

    { sam_cant_reach_peer, "sam cannot reach peer" },

    { sam_duplicated_dest, "sam duplicated destination" },

    { sam_duplicated_id, "sam duplicated session" },

    { sam_i2p_error, "sam i2p error" },

    { sam_invalid_id, "sam invalid session" },

    { sam_invalid_key, "sam invalid key" },

    { sam_key_not_found, "sam key not found" },

    { sam_peer_not_found, "sam peer not found" },

    { sam_timeout, "sam timeout" },

    { sam_unassigned_failure, "sam unassigned failure" },

    // tls

    { tls_use_certificate, "failed to set tls certificate" },

    { tls_use_private_key, "failed to set tls private key" },

    { tls_set_add_verify, "failed to set tls certificate authority" },

    { tls_stream_truncated, "tls stream truncated" },

    // tls alerts

    { tls_alert_unexpected_message, "tls alert unexpected message" },

    { tls_alert_bad_record_mac, "tls alert bad record mac" },

    { tls_alert_record_overflow, "tls alert record overflow" },

    { tls_alert_handshake_failure, "tls alert handshake failure" },

    { tls_alert_bad_certificate, "tls alert bad certificate" },

    { tls_alert_unsupported_certificate, "tls alert unsupported certificate" },

    { tls_alert_certificate_expired, "tls alert certificate expired" },

    { tls_alert_certificate_unknown, "tls alert certificate unknown" },

    { tls_alert_illegal_parameter, "tls alert illegal parameter" },

    { tls_alert_unknown_ca, "tls alert unknown ca" },

    { tls_alert_decode_error, "tls alert decode error" },

    { tls_alert_decrypt_error, "tls alert decrypt error" },

    { tls_alert_protocol_version, "tls alert protocol version" },

    { tls_alert_internal_error, "tls alert internal error" },

    { tls_alert_missing_extension, "tls alert missing extension" },

    { tls_alert_certificate_required, "tls alert certificate required" },

    { tls_alert_unknown, "tls alert" },

    // http 4xx client error

    { bad_request, "bad request" },

    { unauthorized, "unauthorized" },

    ////{ payment_required, "payment required" },

    { forbidden, "forbidden" },

    { not_found, "not found" },

    { method_not_allowed, "method not allowed" },

    { not_acceptable, "not acceptable" },

    ////{ proxy_authentication_required, "proxy authentication required" },

    ////{ request_timeout, "request timeout" },

    ////{ conflict, "conflict" },

    ////{ gone, "gone" },

    ////{ length_required, "length required" },

    ////{ precondition_failed, "precondition failed" },

    ////{ payload_too_large, "payload too large" },

    ////{ uri_too_long, "uri too long" },

    ////{ unsupported_media_type, "unsupported media type" },

    ////{ range_not_satisfiable, "range not satisfiable" },

    ////{ expectation_failed, "expectation failed" },

    ////{ im_a_teapot, "im a teapot" },

    ////{ misdirected_request, "misdirected request" },

    ////{ unprocessable_entity, "unprocessable entity" },

    ////{ locked, "locked" },

    ////{ failed_dependency, "failed dependency" },

    ////{ too_early, "too early" },

    ////{ upgrade_required, "upgrade required" },

    ////{ precondition_required, "precondition required" },

    ////{ too_many_requests, "too many requests" },

    ////{ request_header_fields_too_large, "request header fields too large" },

    ////{ unavailable_for_legal_reasons, "unavailable for legal reasons" },

    // http 5xx server error

    { internal_server_error, "internal server error" },

    { not_implemented, "not implemented" },

    ////{ bad_gateway, "bad gateway" },

    ////{ service_unavailable, "service unavailable" },

    ////{ gateway_timeout, "gateway timeout" },

    ////{ http_version_not_supported, "http version not supported" },

    ////{ variant_also_negotiates, "variant also negotiates" },

    ////{ insufficient_storage, "insufficient storage" },

    ////{ loop_detected, "loop detected" },

    ////{ not_extended, "not extended" },

    ////{ network_authentication_required, "network authentication required" },

    // http error

    { end_of_stream, "end of stream" },

    { partial_message, "partial message" },

    { need_more, "need more" },

    { unexpected_body, "unexpected body" },

    { need_buffer, "need buffer" },

    { end_of_chunk, "end of chunk" },

    { buffer_overflow, "buffer overflow" },

    { header_limit, "header limit" },

    { body_limit, "body limit" },

    { bad_alloc, "bad alloc" },

    { bad_line_ending, "bad line ending" },

    { bad_method, "bad method" },

    { bad_target, "bad target" },

    { bad_version, "bad version" },

    { bad_status, "bad status" },

    { bad_reason, "bad reason" },

    { bad_field, "bad field" },

    { bad_value, "bad value" },

    { bad_content_length, "bad content length" },

    { bad_transfer_encoding, "bad transfer encoding" },

    { bad_chunk, "bad chunk" },

    { bad_chunk_extension, "bad chunk extension" },

    { bad_obs_fold, "bad obs fold" },

    { multiple_content_length, "multiple content length" },

    { stale_parser, "stale parser" },

    { short_read, "short read" },

    { http_unknown, "http error" },

    // websocket error

    { websocket_closed, "websocket closed" },

    { websocket_buffer_overflow, "websocket buffer overflow" },

    { partial_deflate_block, "partial deflate block" },

    { message_too_big, "message too big" },

    { bad_http_version, "bad http version" },

    { websocket_bad_method, "websocket bad method" },

    { no_host, "no host" },

    { no_connection, "no connection" },

    { no_connection_upgrade, "no connection upgrade" },

    { no_upgrade, "no upgrade" },

    { no_upgrade_websocket, "no upgrade websocket" },

    { no_sec_key, "no sec key" },

    { bad_sec_key, "bad sec key" },

    { no_sec_version, "no sec version" },

    { bad_sec_version, "bad sec version" },

    { no_sec_accept, "no sec accept" },

    { bad_sec_accept, "bad sec accept" },

    { upgrade_declined, "upgrade declined" },

    { bad_opcode, "bad opcode" },

    { bad_data_frame, "bad data frame" },

    { bad_continuation, "bad continuation" },

    { bad_reserved_bits, "bad reserved bits" },

    { bad_control_fragment, "bad control fragment" },

    { bad_control_size, "bad control size" },

    { bad_unmasked_frame, "bad unmasked frame" },

    { bad_masked_frame, "bad masked frame" },

    { bad_size, "bad size" },

    { bad_frame_payload, "bad frame payload" },

    { bad_close_code, "bad close code" },

    { bad_close_size, "bad close size" },

    { bad_close_payload, "bad close payload" },

    // json error

    { syntax, "syntax error" },

    { extra_data, "extra data" },

    { incomplete, "incomplete json" },

    { too_deep, "too deep" },

    { invalid_escape, "invalid escape" },

    { expected_hex_digit, "expected hex digit" },

    { expected_utf16_escape, "expected utf16 escape" },

    { illegal_leading_surrogate, "illegal leading surrogate" },

    { illegal_trailing_surrogate, "illegal trailing surrogate" },

    { invalid_utf8, "invalid utf8" },

    { exponent_overflow, "exponent too large" },

    { number_too_large, "number too large" },

    { string_too_large, "string too large" },

    { key_too_large, "key too large" },

    { array_too_large, "array too large" },

    { object_too_large, "object too large" },

    { not_null, "not null" },

    { not_bool, "not bool" },

    { not_number, "not number" },

    { not_int64, "not int64" },

    { not_uint64, "not uint64" },

    { not_double, "not double" },

    { not_string, "not string" },

    { not_array, "not array" },

    { not_object, "not object" },

    { not_exact, "not exact" },

    { out_of_range, "out of range" },

    { size_mismatch, "size mismatch" },

    { exhausted_variants, "exhausted variants" },

    { json_unknown, "json error" },

    // query string parse error

    { undefined_type, "undefined type" },

    { unexpected_method, "unexpected method" },

    { unexpected_type, "unexpected type" },

    { extra_positional, "extra positional" },

    { extra_named, "extra named" },

    { missing_array, "missing array" },

    { missing_object, "missing object" },

    { missing_parameter, "missing parameter" },

    // json-rpc error

    { jsonrpc_invalid_version, "jsonrpc invalid version" },

    { jsonrpc_requires_method, "jsonrpc requires method" },

    { jsonrpc_v1_requires_params, "jsonrpc v1 requires params" },

    { jsonrpc_v1_requires_array_params, "jsonrpc v1 requires array params" },

    { jsonrpc_v1_requires_id, "jsonrpc v1 requires id" },

    { jsonrpc_params_not_collection, "jsonrpc params not collection" },

    { jsonrpc_reader_stall, "jsonrpc reader stall" },

    { jsonrpc_reader_exception, "jsonrpc reader exception" },

    { jsonrpc_writer_exception, "jsonrpc writer exception" },

    { jsonrpc_batch_empty, "jsonrpc batch empty" },

    { jsonrpc_batch_malformed, "jsonrpc batch malformed" },

    { jsonrpc_batch_requires_v2, "jsonrpc batch requires v2" },

    { jsonrpc_batch_unsupported, "jsonrpc batch unsupported" },

    // zmtp (rpc by socket role)

    { zmtp_unexpected_command, "zmtp unexpected command" },

    { zmtp_unexpected_message, "zmtp unexpected message" },

    { zmtp_excessive_parts, "zmtp excessive parts" },

    { zmtp_unserializable, "zmtp unserializable" },

    // io

    { would_block, "would block" }

};

class http_category_t final

  : public std::error_category

{

public:

    {

    }

    {

        {

        }

    }

};

{

}

// includes json codes

{

    {

        {

        }

    }

}

{

    {

    }

}

// network codes pass

{

    {

        {

        }

    }

}

// includes http codes

{

}

BC_POP_WARNING()

} // namespace error

} // namespace network

} // namespace libbitcoin