From 82f24688777fbab6dbccef4a4fbea1ee5e1de09b Mon Sep 17 00:00:00 2001 From: yulin-liang Date: Tue, 22 Sep 2020 10:05:22 -0700 Subject: [PATCH] Roll-forward: Import cronet net error list and modify grpc-cronet error message. --- .../cronet/transport/cronet_status.cc | 536 +++++++-- .../cronet/transport/cronet_status.h | 1051 ++++++++++++++++- .../cronet/transport/cronet_transport.cc | 26 +- 3 files changed, 1503 insertions(+), 110 deletions(-) diff --git a/src/core/ext/transport/cronet/transport/cronet_status.cc b/src/core/ext/transport/cronet/transport/cronet_status.cc index d88c15096d1..c128572528e 100644 --- a/src/core/ext/transport/cronet/transport/cronet_status.cc +++ b/src/core/ext/transport/cronet/transport/cronet_status.cc @@ -20,72 +20,474 @@ #include "src/core/ext/transport/cronet/transport/cronet_status.h" -const char* cronet_status_as_string(cronet_status_code status) { - switch (status) { - case CRONET_STATUS_SUCCESS: - return "CRONET_STATUS_SUCCESS."; - case CRONET_STATUS_ILLEGAL_ARGUMENT: - return "CRONET_STATUS_ILLEGAL_ARGUMENT."; - case CRONET_STATUS_ILLEGAL_ARGUMENT_STORAGE_PATH_MUST_EXIST: - return "CRONET_STATUS_ILLEGAL_ARGUMENT_STORAGE_PATH_MUST_EXIST."; - case CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_PIN: - return "CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_PIN."; - case CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HOSTNAME: - return "CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HOSTNAME."; - case CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_METHOD: - return "CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_METHOD."; - case CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_HEADER: - return "CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_HEADER."; - case CRONET_STATUS_ILLEGAL_STATE: - return "CRONET_STATUS_ILLEGAL_STATE."; - case CRONET_STATUS_ILLEGAL_STATE_STORAGE_PATH_IN_USE: - return "CRONET_STATUS_ILLEGAL_STATE_STORAGE_PATH_IN_USE."; - case CRONET_STATUS_ILLEGAL_STATE_CANNOT_SHUTDOWN_ENGINE_FROM_NETWORK_THREAD: - return "CRONET_STATUS_ILLEGAL_STATE_CANNOT_SHUTDOWN_ENGINE_FROM_NETWORK_" - "THREAD."; - case CRONET_STATUS_ILLEGAL_STATE_ENGINE_ALREADY_STARTED: - return "CRONET_STATUS_ILLEGAL_STATE_ENGINE_ALREADY_STARTED."; - case CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_STARTED: - return "CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_STARTED."; - case CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_INITIALIZED: - return "CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_INITIALIZED."; - case CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_INITIALIZED: - return "CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_INITIALIZED."; - case CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_STARTED: - return "CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_STARTED."; - case CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_REDIRECT: - return "CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_REDIRECT."; - case CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_READ: - return "CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_READ."; - case CRONET_STATUS_ILLEGAL_STATE_READ_FAILED: - return "CRONET_STATUS_ILLEGAL_STATE_READ_FAILED."; - case CRONET_STATUS_NULL_POINTER: - return "CRONET_STATUS_NULL_POINTER."; - case CRONET_STATUS_NULL_POINTER_HOSTNAME: - return "CRONET_STATUS_NULL_POINTER_HOSTNAME."; - case CRONET_STATUS_NULL_POINTER_SHA256_PINS: - return "CRONET_STATUS_NULL_POINTER_SHA256_PINS."; - case CRONET_STATUS_NULL_POINTER_EXPIRATION_DATE: - return "CRONET_STATUS_NULL_POINTER_EXPIRATION_DATE."; - case CRONET_STATUS_NULL_POINTER_ENGINE: - return "CRONET_STATUS_NULL_POINTER_ENGINE."; - case CRONET_STATUS_NULL_POINTER_URL: - return "CRONET_STATUS_NULL_POINTER_URL."; - case CRONET_STATUS_NULL_POINTER_CALLBACK: - return "CRONET_STATUS_NULL_POINTER_CALLBACK."; - case CRONET_STATUS_NULL_POINTER_EXECUTOR: - return "CRONET_STATUS_NULL_POINTER_EXECUTOR."; - case CRONET_STATUS_NULL_POINTER_METHOD: - return "CRONET_STATUS_NULL_POINTER_METHOD."; - case CRONET_STATUS_NULL_POINTER_HEADER_NAME: - return "CRONET_STATUS_NULL_POINTER_HEADER_NAME."; - case CRONET_STATUS_NULL_POINTER_HEADER_VALUE: - return "CRONET_STATUS_NULL_POINTER_HEADER_VALUE"; - case CRONET_STATUS_NULL_POINTER_PARAMS: - return "CRONET_STATUS_NULL_POINTER_PARAMS."; - case CRONET_STATUS_NULL_POINTER_REQUEST_FINISHED_INFO_LISTENER_EXECUTOR: - return "CRONET_STATUS_NULL_POINTER_REQUEST_FINISHED_INFO_LISTENER_" - "EXECUTOR."; +const char* cronet_net_error_as_string(cronet_net_error_code net_error) { + switch (net_error) { + case OK: + return "OK"; + case CRONET_NET_ERROR_IO_PENDING: + return "CRONET_NET_ERROR_IO_PENDING"; + case CRONET_NET_ERROR_FAILED: + return "CRONET_NET_ERROR_FAILED"; + case CRONET_NET_ERROR_ABORTED: + return "CRONET_NET_ERROR_ABORTED"; + case CRONET_NET_ERROR_INVALID_ARGUMENT: + return "CRONET_NET_ERROR_INVALID_ARGUMENT"; + case CRONET_NET_ERROR_INVALID_HANDLE: + return "CRONET_NET_ERROR_INVALID_HANDLE"; + case CRONET_NET_ERROR_FILE_NOT_FOUND: + return "CRONET_NET_ERROR_FILE_NOT_FOUND"; + case CRONET_NET_ERROR_TIMED_OUT: + return "CRONET_NET_ERROR_TIMED_OUT"; + case CRONET_NET_ERROR_FILE_TOO_BIG: + return "CRONET_NET_ERROR_FILE_TOO_BIG"; + case CRONET_NET_ERROR_UNEXPECTED: + return "CRONET_NET_ERROR_UNEXPECTED"; + case CRONET_NET_ERROR_ACCESS_DENIED: + return "CRONET_NET_ERROR_ACCESS_DENIED"; + case CRONET_NET_ERROR_NOT_IMPLEMENTED: + return "CRONET_NET_ERROR_NOT_IMPLEMENTED"; + case CRONET_NET_ERROR_INSUFFICIENT_RESOURCES: + return "CRONET_NET_ERROR_INSUFFICIENT_RESOURCES"; + case CRONET_NET_ERROR_OUT_OF_MEMORY: + return "CRONET_NET_ERROR_OUT_OF_MEMORY"; + case CRONET_NET_ERROR_UPLOAD_FILE_CHANGED: + return "CRONET_NET_ERROR_UPLOAD_FILE_CHANGED"; + case CRONET_NET_ERROR_SOCKET_NOT_CONNECTED: + return "CRONET_NET_ERROR_SOCKET_NOT_CONNECTED"; + case CRONET_NET_ERROR_FILE_EXISTS: + return "CRONET_NET_ERROR_FILE_EXISTS"; + case CRONET_NET_ERROR_FILE_PATH_TOO_LONG: + return "CRONET_NET_ERROR_FILE_PATH_TOO_LONG"; + case CRONET_NET_ERROR_FILE_NO_SPACE: + return "CRONET_NET_ERROR_FILE_NO_SPACE"; + case CRONET_NET_ERROR_FILE_VIRUS_INFECTED: + return "CRONET_NET_ERROR_FILE_VIRUS_INFECTED"; + case CRONET_NET_ERROR_BLOCKED_BY_CLIENT: + return "CRONET_NET_ERROR_BLOCKED_BY_CLIENT"; + case CRONET_NET_ERROR_NETWORK_CHANGED: + return "CRONET_NET_ERROR_NETWORK_CHANGED"; + case CRONET_NET_ERROR_BLOCKED_BY_ADMINISTRATOR: + return "CRONET_NET_ERROR_BLOCKED_BY_ADMINISTRATOR"; + case CRONET_NET_ERROR_SOCKET_IS_CONNECTED: + return "CRONET_NET_ERROR_SOCKET_IS_CONNECTED"; + case CRONET_NET_ERROR_BLOCKED_ENROLLMENT_CHECK_PENDING: + return "CRONET_NET_ERROR_BLOCKED_ENROLLMENT_CHECK_PENDING"; + case CRONET_NET_ERROR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED: + return "CRONET_NET_ERROR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED"; + case CRONET_NET_ERROR_CONTEXT_SHUT_DOWN: + return "CRONET_NET_ERROR_CONTEXT_SHUT_DOWN"; + case CRONET_NET_ERROR_BLOCKED_BY_RESPONSE: + return "CRONET_NET_ERROR_BLOCKED_BY_RESPONSE"; + case CRONET_NET_ERROR_CLEARTEXT_NOT_PERMITTED: + return "CRONET_NET_ERROR_CLEARTEXT_NOT_PERMITTED"; + case CRONET_NET_ERROR_BLOCKED_BY_CSP: + return "CRONET_NET_ERROR_BLOCKED_BY_CSP"; + case CRONET_NET_ERROR_H2_OR_QUIC_REQUIRED: + return "CRONET_NET_ERROR_H2_OR_QUIC_REQUIRED"; + case CRONET_NET_ERROR_INSECURE_PRIVATE_NETWORK_REQUEST: + return "CRONET_NET_ERROR_INSECURE_PRIVATE_NETWORK_REQUEST"; + case CRONET_NET_ERROR_CONNECTION_CLOSED: + return "CRONET_NET_ERROR_CONNECTION_CLOSED"; + case CRONET_NET_ERROR_CONNECTION_RESET: + return "CRONET_NET_ERROR_CONNECTION_RESET"; + case CRONET_NET_ERROR_CONNECTION_REFUSED: + return "CRONET_NET_ERROR_CONNECTION_REFUSED"; + case CRONET_NET_ERROR_CONNECTION_ABORTED: + return "CRONET_NET_ERROR_CONNECTION_ABORTED"; + case CRONET_NET_ERROR_CONNECTION_FAILED: + return "CRONET_NET_ERROR_CONNECTION_FAILED"; + case CRONET_NET_ERROR_NAME_NOT_RESOLVED: + return "CRONET_NET_ERROR_NAME_NOT_RESOLVED"; + case CRONET_NET_ERROR_INTERNET_DISCONNECTED: + return "CRONET_NET_ERROR_INTERNET_DISCONNECTED"; + case CRONET_NET_ERROR_SSL_PROTOCOL_ERROR: + return "CRONET_NET_ERROR_SSL_PROTOCOL_ERROR"; + case CRONET_NET_ERROR_ADDRESS_INVALID: + return "CRONET_NET_ERROR_ADDRESS_INVALID"; + case CRONET_NET_ERROR_ADDRESS_UNREACHABLE: + return "CRONET_NET_ERROR_ADDRESS_UNREACHABLE"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NEEDED: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NEEDED"; + case CRONET_NET_ERROR_TUNNEL_CONNECTION_FAILED: + return "CRONET_NET_ERROR_TUNNEL_CONNECTION_FAILED"; + case CRONET_NET_ERROR_NO_SSL_VERSIONS_ENABLED: + return "CRONET_NET_ERROR_NO_SSL_VERSIONS_ENABLED"; + case CRONET_NET_ERROR_SSL_VERSION_OR_CIPHER_MISMATCH: + return "CRONET_NET_ERROR_SSL_VERSION_OR_CIPHER_MISMATCH"; + case CRONET_NET_ERROR_SSL_RENEGOTIATION_REQUESTED: + return "CRONET_NET_ERROR_SSL_RENEGOTIATION_REQUESTED"; + case CRONET_NET_ERROR_PROXY_AUTH_UNSUPPORTED: + return "CRONET_NET_ERROR_PROXY_AUTH_UNSUPPORTED"; + case CRONET_NET_ERROR_CERT_ERROR_IN_SSL_RENEGOTIATION: + return "CRONET_NET_ERROR_CERT_ERROR_IN_SSL_RENEGOTIATION"; + case CRONET_NET_ERROR_BAD_SSL_CLIENT_AUTH_CERT: + return "CRONET_NET_ERROR_BAD_SSL_CLIENT_AUTH_CERT"; + case CRONET_NET_ERROR_CONNECTION_TIMED_OUT: + return "CRONET_NET_ERROR_CONNECTION_TIMED_OUT"; + case CRONET_NET_ERROR_HOST_RESOLVER_QUEUE_TOO_LARGE: + return "CRONET_NET_ERROR_HOST_RESOLVER_QUEUE_TOO_LARGE"; + case CRONET_NET_ERROR_SOCKS_CONNECTION_FAILED: + return "CRONET_NET_ERROR_SOCKS_CONNECTION_FAILED"; + case CRONET_NET_ERROR_SOCKS_CONNECTION_HOST_UNREACHABLE: + return "CRONET_NET_ERROR_SOCKS_CONNECTION_HOST_UNREACHABLE"; + case CRONET_NET_ERROR_ALPN_NEGOTIATION_FAILED: + return "CRONET_NET_ERROR_ALPN_NEGOTIATION_FAILED"; + case CRONET_NET_ERROR_SSL_NO_RENEGOTIATION: + return "CRONET_NET_ERROR_SSL_NO_RENEGOTIATION"; + case CRONET_NET_ERROR_WINSOCK_UNEXPECTED_WRITTEN_BYTES: + return "CRONET_NET_ERROR_WINSOCK_UNEXPECTED_WRITTEN_BYTES"; + case CRONET_NET_ERROR_SSL_DECOMPRESSION_FAILURE_ALERT: + return "CRONET_NET_ERROR_SSL_DECOMPRESSION_FAILURE_ALERT"; + case CRONET_NET_ERROR_SSL_BAD_RECORD_MAC_ALERT: + return "CRONET_NET_ERROR_SSL_BAD_RECORD_MAC_ALERT"; + case CRONET_NET_ERROR_PROXY_AUTH_REQUESTED: + return "CRONET_NET_ERROR_PROXY_AUTH_REQUESTED"; + case CRONET_NET_ERROR_PROXY_CONNECTION_FAILED: + return "CRONET_NET_ERROR_PROXY_CONNECTION_FAILED"; + case CRONET_NET_ERROR_MANDATORY_PROXY_CONFIGURATION_FAILED: + return "CRONET_NET_ERROR_MANDATORY_PROXY_CONFIGURATION_FAILED"; + case CRONET_NET_ERROR_PRECONNECT_MAX_SOCKET_LIMIT: + return "CRONET_NET_ERROR_PRECONNECT_MAX_SOCKET_LIMIT"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY"; + case CRONET_NET_ERROR_PROXY_CERTIFICATE_INVALID: + return "CRONET_NET_ERROR_PROXY_CERTIFICATE_INVALID"; + case CRONET_NET_ERROR_NAME_RESOLUTION_FAILED: + return "CRONET_NET_ERROR_NAME_RESOLUTION_FAILED"; + case CRONET_NET_ERROR_NETWORK_ACCESS_DENIED: + return "CRONET_NET_ERROR_NETWORK_ACCESS_DENIED"; + case CRONET_NET_ERROR_TEMPORARILY_THROTTLED: + return "CRONET_NET_ERROR_TEMPORARILY_THROTTLED"; + case CRONET_NET_ERROR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT: + return "CRONET_NET_ERROR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_SIGNATURE_FAILED: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_SIGNATURE_FAILED"; + case CRONET_NET_ERROR_MSG_TOO_BIG: + return "CRONET_NET_ERROR_MSG_TOO_BIG"; + case CRONET_NET_ERROR_WS_PROTOCOL_ERROR: + return "CRONET_NET_ERROR_WS_PROTOCOL_ERROR"; + case CRONET_NET_ERROR_ADDRESS_IN_USE: + return "CRONET_NET_ERROR_ADDRESS_IN_USE"; + case CRONET_NET_ERROR_SSL_HANDSHAKE_NOT_COMPLETED: + return "CRONET_NET_ERROR_SSL_HANDSHAKE_NOT_COMPLETED"; + case CRONET_NET_ERROR_SSL_BAD_PEER_PUBLIC_KEY: + return "CRONET_NET_ERROR_SSL_BAD_PEER_PUBLIC_KEY"; + case CRONET_NET_ERROR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN: + return "CRONET_NET_ERROR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN"; + case CRONET_NET_ERROR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED: + return "CRONET_NET_ERROR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED"; + case CRONET_NET_ERROR_SSL_DECRYPT_ERROR_ALERT: + return "CRONET_NET_ERROR_SSL_DECRYPT_ERROR_ALERT"; + case CRONET_NET_ERROR_WS_THROTTLE_QUEUE_TOO_LARGE: + return "CRONET_NET_ERROR_WS_THROTTLE_QUEUE_TOO_LARGE"; + case CRONET_NET_ERROR_SSL_SERVER_CERT_CHANGED: + return "CRONET_NET_ERROR_SSL_SERVER_CERT_CHANGED"; + case CRONET_NET_ERROR_SSL_UNRECOGNIZED_NAME_ALERT: + return "CRONET_NET_ERROR_SSL_UNRECOGNIZED_NAME_ALERT"; + case CRONET_NET_ERROR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR: + return "CRONET_NET_ERROR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR"; + case CRONET_NET_ERROR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR: + return "CRONET_NET_ERROR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR"; + case CRONET_NET_ERROR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE: + return "CRONET_NET_ERROR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE"; + case CRONET_NET_ERROR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE: + return "CRONET_NET_ERROR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT"; + case CRONET_NET_ERROR_ICANN_NAME_COLLISION: + return "CRONET_NET_ERROR_ICANN_NAME_COLLISION"; + case CRONET_NET_ERROR_SSL_SERVER_CERT_BAD_FORMAT: + return "CRONET_NET_ERROR_SSL_SERVER_CERT_BAD_FORMAT"; + case CRONET_NET_ERROR_CT_STH_PARSING_FAILED: + return "CRONET_NET_ERROR_CT_STH_PARSING_FAILED"; + case CRONET_NET_ERROR_CT_STH_INCOMPLETE: + return "CRONET_NET_ERROR_CT_STH_INCOMPLETE"; + case CRONET_NET_ERROR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH: + return "CRONET_NET_ERROR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH"; + case CRONET_NET_ERROR_CT_CONSISTENCY_PROOF_PARSING_FAILED: + return "CRONET_NET_ERROR_CT_CONSISTENCY_PROOF_PARSING_FAILED"; + case CRONET_NET_ERROR_SSL_OBSOLETE_CIPHER: + return "CRONET_NET_ERROR_SSL_OBSOLETE_CIPHER"; + case CRONET_NET_ERROR_WS_UPGRADE: + return "CRONET_NET_ERROR_WS_UPGRADE"; + case CRONET_NET_ERROR_READ_IF_READY_NOT_IMPLEMENTED: + return "CRONET_NET_ERROR_READ_IF_READY_NOT_IMPLEMENTED"; + case CRONET_NET_ERROR_NO_BUFFER_SPACE: + return "CRONET_NET_ERROR_NO_BUFFER_SPACE"; + case CRONET_NET_ERROR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS: + return "CRONET_NET_ERROR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS"; + case CRONET_NET_ERROR_EARLY_DATA_REJECTED: + return "CRONET_NET_ERROR_EARLY_DATA_REJECTED"; + case CRONET_NET_ERROR_WRONG_VERSION_ON_EARLY_DATA: + return "CRONET_NET_ERROR_WRONG_VERSION_ON_EARLY_DATA"; + case CRONET_NET_ERROR_TLS13_DOWNGRADE_DETECTED: + return "CRONET_NET_ERROR_TLS13_DOWNGRADE_DETECTED"; + case CRONET_NET_ERROR_SSL_KEY_USAGE_INCOMPATIBLE: + return "CRONET_NET_ERROR_SSL_KEY_USAGE_INCOMPATIBLE"; + case CRONET_NET_ERROR_CERT_COMMON_NAME_INVALID: + return "CRONET_NET_ERROR_CERT_COMMON_NAME_INVALID"; + case CRONET_NET_ERROR_CERT_DATE_INVALID: + return "CRONET_NET_ERROR_CERT_DATE_INVALID"; + case CRONET_NET_ERROR_CERT_AUTHORITY_INVALID: + return "CRONET_NET_ERROR_CERT_AUTHORITY_INVALID"; + case CRONET_NET_ERROR_CERT_CONTAINS_ERRORS: + return "CRONET_NET_ERROR_CERT_CONTAINS_ERRORS"; + case CRONET_NET_ERROR_CERT_NO_REVOCATION_MECHANISM: + return "CRONET_NET_ERROR_CERT_NO_REVOCATION_MECHANISM"; + case CRONET_NET_ERROR_CERT_UNABLE_TO_CHECK_REVOCATION: + return "CRONET_NET_ERROR_CERT_UNABLE_TO_CHECK_REVOCATION"; + case CRONET_NET_ERROR_CERT_REVOKED: + return "CRONET_NET_ERROR_CERT_REVOKED"; + case CRONET_NET_ERROR_CERT_INVALID: + return "CRONET_NET_ERROR_CERT_INVALID"; + case CRONET_NET_ERROR_CERT_WEAK_SIGNATURE_ALGORITHM: + return "CRONET_NET_ERROR_CERT_WEAK_SIGNATURE_ALGORITHM"; + case CRONET_NET_ERROR_CERT_NON_UNIQUE_NAME: + return "CRONET_NET_ERROR_CERT_NON_UNIQUE_NAME"; + case CRONET_NET_ERROR_CERT_WEAK_KEY: + return "CRONET_NET_ERROR_CERT_WEAK_KEY"; + case CRONET_NET_ERROR_CERT_NAME_CONSTRAINT_VIOLATION: + return "CRONET_NET_ERROR_CERT_NAME_CONSTRAINT_VIOLATION"; + case CRONET_NET_ERROR_CERT_VALIDITY_TOO_LONG: + return "CRONET_NET_ERROR_CERT_VALIDITY_TOO_LONG"; + case CRONET_NET_ERROR_CERTIFICATE_TRANSPARENCY_REQUIRED: + return "CRONET_NET_ERROR_CERTIFICATE_TRANSPARENCY_REQUIRED"; + case CRONET_NET_ERROR_CERT_SYMANTEC_LEGACY: + return "CRONET_NET_ERROR_CERT_SYMANTEC_LEGACY"; + case CRONET_NET_ERROR_CERT_KNOWN_INTERCEPTION_BLOCKED: + return "CRONET_NET_ERROR_CERT_KNOWN_INTERCEPTION_BLOCKED"; + case CRONET_NET_ERROR_SSL_OBSOLETE_VERSION: + return "CRONET_NET_ERROR_SSL_OBSOLETE_VERSION"; + case CRONET_NET_ERROR_CERT_END: + return "CRONET_NET_ERROR_CERT_END"; + case CRONET_NET_ERROR_INVALID_URL: + return "CRONET_NET_ERROR_INVALID_URL"; + case CRONET_NET_ERROR_DISALLOWED_URL_SCHEME: + return "CRONET_NET_ERROR_DISALLOWED_URL_SCHEME"; + case CRONET_NET_ERROR_UNKNOWN_URL_SCHEME: + return "CRONET_NET_ERROR_UNKNOWN_URL_SCHEME"; + case CRONET_NET_ERROR_INVALID_REDIRECT: + return "CRONET_NET_ERROR_INVALID_REDIRECT"; + case CRONET_NET_ERROR_TOO_MANY_REDIRECTS: + return "CRONET_NET_ERROR_TOO_MANY_REDIRECTS"; + case CRONET_NET_ERROR_UNSAFE_REDIRECT: + return "CRONET_NET_ERROR_UNSAFE_REDIRECT"; + case CRONET_NET_ERROR_UNSAFE_PORT: + return "CRONET_NET_ERROR_UNSAFE_PORT"; + case CRONET_NET_ERROR_INVALID_RESPONSE: + return "CRONET_NET_ERROR_INVALID_RESPONSE"; + case CRONET_NET_ERROR_INVALID_CHUNKED_ENCODING: + return "CRONET_NET_ERROR_INVALID_CHUNKED_ENCODING"; + case CRONET_NET_ERROR_METHOD_NOT_SUPPORTED: + return "CRONET_NET_ERROR_METHOD_NOT_SUPPORTED"; + case CRONET_NET_ERROR_UNEXPECTED_PROXY_AUTH: + return "CRONET_NET_ERROR_UNEXPECTED_PROXY_AUTH"; + case CRONET_NET_ERROR_EMPTY_RESPONSE: + return "CRONET_NET_ERROR_EMPTY_RESPONSE"; + case CRONET_NET_ERROR_RESPONSE_HEADERS_TOO_BIG: + return "CRONET_NET_ERROR_RESPONSE_HEADERS_TOO_BIG"; + case CRONET_NET_ERROR_PAC_SCRIPT_FAILED: + return "CRONET_NET_ERROR_PAC_SCRIPT_FAILED"; + case CRONET_NET_ERROR_REQUEST_RANGE_NOT_SATISFIABLE: + return "CRONET_NET_ERROR_REQUEST_RANGE_NOT_SATISFIABLE"; + case CRONET_NET_ERROR_MALFORMED_IDENTITY: + return "CRONET_NET_ERROR_MALFORMED_IDENTITY"; + case CRONET_NET_ERROR_CONTENT_DECODING_FAILED: + return "CRONET_NET_ERROR_CONTENT_DECODING_FAILED"; + case CRONET_NET_ERROR_NETWORK_IO_SUSPENDED: + return "CRONET_NET_ERROR_NETWORK_IO_SUSPENDED"; + case CRONET_NET_ERROR_SYN_REPLY_NOT_RECEIVED: + return "CRONET_NET_ERROR_SYN_REPLY_NOT_RECEIVED"; + case CRONET_NET_ERROR_ENCODING_CONVERSION_FAILED: + return "CRONET_NET_ERROR_ENCODING_CONVERSION_FAILED"; + case CRONET_NET_ERROR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT: + return "CRONET_NET_ERROR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT"; + return "CRONET_NET_ERROR_INVALID_SPDY_STREAM"; + case CRONET_NET_ERROR_NO_SUPPORTED_PROXIES: + return "CRONET_NET_ERROR_NO_SUPPORTED_PROXIES"; + case CRONET_NET_ERROR_HTTP2_PROTOCOL_ERROR: + return "CRONET_NET_ERROR_HTTP2_PROTOCOL_ERROR"; + case CRONET_NET_ERROR_INVALID_AUTH_CREDENTIALS: + return "CRONET_NET_ERROR_INVALID_AUTH_CREDENTIALS"; + case CRONET_NET_ERROR_UNSUPPORTED_AUTH_SCHEME: + return "CRONET_NET_ERROR_UNSUPPORTED_AUTH_SCHEME"; + case CRONET_NET_ERROR_ENCODING_DETECTION_FAILED: + return "CRONET_NET_ERROR_ENCODING_DETECTION_FAILED"; + case CRONET_NET_ERROR_MISSING_AUTH_CREDENTIALS: + return "CRONET_NET_ERROR_MISSING_AUTH_CREDENTIALS"; + case CRONET_NET_ERROR_UNEXPECTED_SECURITY_LIBRARY_STATUS: + return "CRONET_NET_ERROR_UNEXPECTED_SECURITY_LIBRARY_STATUS"; + case CRONET_NET_ERROR_MISCONFIGURED_AUTH_ENVIRONMENT: + return "CRONET_NET_ERROR_MISCONFIGURED_AUTH_ENVIRONMENT"; + case CRONET_NET_ERROR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS: + return "CRONET_NET_ERROR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS"; + case CRONET_NET_ERROR_RESPONSE_BODY_TOO_BIG_TO_DRAIN: + return "CRONET_NET_ERROR_RESPONSE_BODY_TOO_BIG_TO_DRAIN"; + case CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH: + return "CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH"; + case CRONET_NET_ERROR_INCOMPLETE_HTTP2_HEADERS: + return "CRONET_NET_ERROR_INCOMPLETE_HTTP2_HEADERS"; + case CRONET_NET_ERROR_PAC_NOT_IN_DHCP: + return "CRONET_NET_ERROR_PAC_NOT_IN_DHCP"; + case CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION: + return "CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION"; + case CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_LOCATION: + return "CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_LOCATION"; + case CRONET_NET_ERROR_HTTP2_SERVER_REFUSED_STREAM: + return "CRONET_NET_ERROR_HTTP2_SERVER_REFUSED_STREAM"; + case CRONET_NET_ERROR_HTTP2_PING_FAILED: + return "CRONET_NET_ERROR_HTTP2_PING_FAILED"; + return "CRONET_NET_ERROR_PIPELINE_EVICTION"; + case CRONET_NET_ERROR_CONTENT_LENGTH_MISMATCH: + return "CRONET_NET_ERROR_CONTENT_LENGTH_MISMATCH"; + case CRONET_NET_ERROR_INCOMPLETE_CHUNKED_ENCODING: + return "CRONET_NET_ERROR_INCOMPLETE_CHUNKED_ENCODING"; + case CRONET_NET_ERROR_QUIC_PROTOCOL_ERROR: + return "CRONET_NET_ERROR_QUIC_PROTOCOL_ERROR"; + case CRONET_NET_ERROR_RESPONSE_HEADERS_TRUNCATED: + return "CRONET_NET_ERROR_RESPONSE_HEADERS_TRUNCATED"; + case CRONET_NET_ERROR_QUIC_HANDSHAKE_FAILED: + return "CRONET_NET_ERROR_QUIC_HANDSHAKE_FAILED"; + return "CRONET_NET_ERROR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC"; + case CRONET_NET_ERROR_HTTP2_INADEQUATE_TRANSPORT_SECURITY: + return "CRONET_NET_ERROR_HTTP2_INADEQUATE_TRANSPORT_SECURITY"; + case CRONET_NET_ERROR_HTTP2_FLOW_CONTROL_ERROR: + return "CRONET_NET_ERROR_HTTP2_FLOW_CONTROL_ERROR"; + case CRONET_NET_ERROR_HTTP2_FRAME_SIZE_ERROR: + return "CRONET_NET_ERROR_HTTP2_FRAME_SIZE_ERROR"; + case CRONET_NET_ERROR_HTTP2_COMPRESSION_ERROR: + return "CRONET_NET_ERROR_HTTP2_COMPRESSION_ERROR"; + case CRONET_NET_ERROR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION: + return "CRONET_NET_ERROR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION"; + case CRONET_NET_ERROR_HTTP_1_1_REQUIRED: + return "CRONET_NET_ERROR_HTTP_1_1_REQUIRED"; + case CRONET_NET_ERROR_PROXY_HTTP_1_1_REQUIRED: + return "CRONET_NET_ERROR_PROXY_HTTP_1_1_REQUIRED"; + case CRONET_NET_ERROR_PAC_SCRIPT_TERMINATED: + return "CRONET_NET_ERROR_PAC_SCRIPT_TERMINATED"; + return "CRONET_NET_ERROR_TEMPORARY_BACKOFF"; + case CRONET_NET_ERROR_INVALID_HTTP_RESPONSE: + return "CRONET_NET_ERROR_INVALID_HTTP_RESPONSE"; + case CRONET_NET_ERROR_CONTENT_DECODING_INIT_FAILED: + return "CRONET_NET_ERROR_CONTENT_DECODING_INIT_FAILED"; + case CRONET_NET_ERROR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED: + return "CRONET_NET_ERROR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED"; + case CRONET_NET_ERROR_HTTP2_PUSHED_STREAM_NOT_AVAILABLE: + return "CRONET_NET_ERROR_HTTP2_PUSHED_STREAM_NOT_AVAILABLE"; + case CRONET_NET_ERROR_HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER: + return "CRONET_NET_ERROR_HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER"; + case CRONET_NET_ERROR_TOO_MANY_RETRIES: + return "CRONET_NET_ERROR_TOO_MANY_RETRIES"; + case CRONET_NET_ERROR_HTTP2_STREAM_CLOSED: + return "CRONET_NET_ERROR_HTTP2_STREAM_CLOSED"; + case CRONET_NET_ERROR_HTTP2_CLIENT_REFUSED_STREAM: + return "CRONET_NET_ERROR_HTTP2_CLIENT_REFUSED_STREAM"; + case CRONET_NET_ERROR_HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH: + return "CRONET_NET_ERROR_HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH"; + case CRONET_NET_ERROR_HTTP_RESPONSE_CODE_FAILURE: + return "CRONET_NET_ERROR_HTTP_RESPONSE_CODE_FAILURE"; + case CRONET_NET_ERROR_QUIC_CERT_ROOT_NOT_KNOWN: + return "CRONET_NET_ERROR_QUIC_CERT_ROOT_NOT_KNOWN"; + case CRONET_NET_ERROR_CACHE_MISS: + return "CRONET_NET_ERROR_CACHE_MISS"; + case CRONET_NET_ERROR_CACHE_READ_FAILURE: + return "CRONET_NET_ERROR_CACHE_READ_FAILURE"; + case CRONET_NET_ERROR_CACHE_WRITE_FAILURE: + return "CRONET_NET_ERROR_CACHE_WRITE_FAILURE"; + case CRONET_NET_ERROR_CACHE_OPERATION_NOT_SUPPORTED: + return "CRONET_NET_ERROR_CACHE_OPERATION_NOT_SUPPORTED"; + case CRONET_NET_ERROR_CACHE_OPEN_FAILURE: + return "CRONET_NET_ERROR_CACHE_OPEN_FAILURE"; + case CRONET_NET_ERROR_CACHE_CREATE_FAILURE: + return "CRONET_NET_ERROR_CACHE_CREATE_FAILURE"; + case CRONET_NET_ERROR_CACHE_RACE: + return "CRONET_NET_ERROR_CACHE_RACE"; + case CRONET_NET_ERROR_CACHE_CHECKSUM_READ_FAILURE: + return "CRONET_NET_ERROR_CACHE_CHECKSUM_READ_FAILURE"; + case CRONET_NET_ERROR_CACHE_CHECKSUM_MISMATCH: + return "CRONET_NET_ERROR_CACHE_CHECKSUM_MISMATCH"; + case CRONET_NET_ERROR_CACHE_LOCK_TIMEOUT: + return "CRONET_NET_ERROR_CACHE_LOCK_TIMEOUT"; + case CRONET_NET_ERROR_CACHE_AUTH_FAILURE_AFTER_READ: + return "CRONET_NET_ERROR_CACHE_AUTH_FAILURE_AFTER_READ"; + case CRONET_NET_ERROR_CACHE_ENTRY_NOT_SUITABLE: + return "CRONET_NET_ERROR_CACHE_ENTRY_NOT_SUITABLE"; + case CRONET_NET_ERROR_CACHE_DOOM_FAILURE: + return "CRONET_NET_ERROR_CACHE_DOOM_FAILURE"; + case CRONET_NET_ERROR_CACHE_OPEN_OR_CREATE_FAILURE: + return "CRONET_NET_ERROR_CACHE_OPEN_OR_CREATE_FAILURE"; + case CRONET_NET_ERROR_INSECURE_RESPONSE: + return "CRONET_NET_ERROR_INSECURE_RESPONSE"; + case CRONET_NET_ERROR_NO_PRIVATE_KEY_FOR_CERT: + return "CRONET_NET_ERROR_NO_PRIVATE_KEY_FOR_CERT"; + case CRONET_NET_ERROR_ADD_USER_CERT_FAILED: + return "CRONET_NET_ERROR_ADD_USER_CERT_FAILED"; + case CRONET_NET_ERROR_INVALID_SIGNED_EXCHANGE: + return "CRONET_NET_ERROR_INVALID_SIGNED_EXCHANGE"; + case CRONET_NET_ERROR_INVALID_WEB_BUNDLE: + return "CRONET_NET_ERROR_INVALID_WEB_BUNDLE"; + case CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_FAILED: + return "CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_FAILED"; + case CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_CACHE_HIT: + return "CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_CACHE_HIT"; + case CRONET_NET_ERROR_FTP_FAILED: + return "CRONET_NET_ERROR_FTP_FAILED"; + case CRONET_NET_ERROR_FTP_SERVICE_UNAVAILABLE: + return "CRONET_NET_ERROR_FTP_SERVICE_UNAVAILABLE"; + case CRONET_NET_ERROR_FTP_TRANSFER_ABORTED: + return "CRONET_NET_ERROR_FTP_TRANSFER_ABORTED"; + case CRONET_NET_ERROR_FTP_FILE_BUSY: + return "CRONET_NET_ERROR_FTP_FILE_BUSY"; + case CRONET_NET_ERROR_FTP_SYNTAX_ERROR: + return "CRONET_NET_ERROR_FTP_SYNTAX_ERROR"; + case CRONET_NET_ERROR_FTP_COMMAND_NOT_SUPPORTED: + return "CRONET_NET_ERROR_FTP_COMMAND_NOT_SUPPORTED"; + case CRONET_NET_ERROR_FTP_BAD_COMMAND_SEQUENCE: + return "CRONET_NET_ERROR_FTP_BAD_COMMAND_SEQUENCE"; + case CRONET_NET_ERROR_PKCS12_IMPORT_BAD_PASSWORD: + return "CRONET_NET_ERROR_PKCS12_IMPORT_BAD_PASSWORD"; + case CRONET_NET_ERROR_PKCS12_IMPORT_FAILED: + return "CRONET_NET_ERROR_PKCS12_IMPORT_FAILED"; + case CRONET_NET_ERROR_IMPORT_CA_CERT_NOT_CA: + return "CRONET_NET_ERROR_IMPORT_CA_CERT_NOT_CA"; + case CRONET_NET_ERROR_IMPORT_CERT_ALREADY_EXISTS: + return "CRONET_NET_ERROR_IMPORT_CERT_ALREADY_EXISTS"; + case CRONET_NET_ERROR_IMPORT_CA_CERT_FAILED: + return "CRONET_NET_ERROR_IMPORT_CA_CERT_FAILED"; + case CRONET_NET_ERROR_IMPORT_SERVER_CERT_FAILED: + return "CRONET_NET_ERROR_IMPORT_SERVER_CERT_FAILED"; + case CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_MAC: + return "CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_MAC"; + case CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_FILE: + return "CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_FILE"; + case CRONET_NET_ERROR_PKCS12_IMPORT_UNSUPPORTED: + return "CRONET_NET_ERROR_PKCS12_IMPORT_UNSUPPORTED"; + case CRONET_NET_ERROR_KEY_GENERATION_FAILED: + return "CRONET_NET_ERROR_KEY_GENERATION_FAILED"; + case CRONET_NET_ERROR_PRIVATE_KEY_EXPORT_FAILED: + return "CRONET_NET_ERROR_PRIVATE_KEY_EXPORT_FAILED"; + case CRONET_NET_ERROR_SELF_SIGNED_CERT_GENERATION_FAILED: + return "CRONET_NET_ERROR_SELF_SIGNED_CERT_GENERATION_FAILED"; + case CRONET_NET_ERROR_CERT_DATABASE_CHANGED: + return "CRONET_NET_ERROR_CERT_DATABASE_CHANGED"; + case CRONET_NET_ERROR_DNS_MALFORMED_RESPONSE: + return "CRONET_NET_ERROR_DNS_MALFORMED_RESPONSE"; + case CRONET_NET_ERROR_DNS_SERVER_REQUIRES_TCP: + return "CRONET_NET_ERROR_DNS_SERVER_REQUIRES_TCP"; + case CRONET_NET_ERROR_DNS_SERVER_FAILED: + return "CRONET_NET_ERROR_DNS_SERVER_FAILED"; + case CRONET_NET_ERROR_DNS_TIMED_OUT: + return "CRONET_NET_ERROR_DNS_TIMED_OUT"; + case CRONET_NET_ERROR_DNS_CACHE_MISS: + return "CRONET_NET_ERROR_DNS_CACHE_MISS"; + case CRONET_NET_ERROR_DNS_SEARCH_EMPTY: + return "CRONET_NET_ERROR_DNS_SEARCH_EMPTY"; + case CRONET_NET_ERROR_DNS_SORT_ERROR: + return "CRONET_NET_ERROR_DNS_SORT_ERROR"; + case CRONET_NET_ERROR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED: + return "CRONET_NET_ERROR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED"; } return "UNAVAILABLE."; -} +} \ No newline at end of file diff --git a/src/core/ext/transport/cronet/transport/cronet_status.h b/src/core/ext/transport/cronet/transport/cronet_status.h index 606dd6f9cdb..a1fa6bccffe 100644 --- a/src/core/ext/transport/cronet/transport/cronet_status.h +++ b/src/core/ext/transport/cronet/transport/cronet_status.h @@ -19,41 +19,1024 @@ #ifndef GRPC_CORE_EXT_TRANSPORT_CRONET_TRANSPORT_CRONET_STATUS_H #define GRPC_CORE_EXT_TRANSPORT_CRONET_TRANSPORT_CRONET_STATUS_H -/* HTTP/2 error codes are mapped to the following cronet net error codes */ -enum cronet_status_code { - CRONET_STATUS_SUCCESS = 0, - CRONET_STATUS_ILLEGAL_ARGUMENT = -100, - CRONET_STATUS_ILLEGAL_ARGUMENT_STORAGE_PATH_MUST_EXIST = -101, - CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_PIN = -102, - CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HOSTNAME = -103, - CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_METHOD = -104, - CRONET_STATUS_ILLEGAL_ARGUMENT_INVALID_HTTP_HEADER = -105, - CRONET_STATUS_ILLEGAL_STATE = -200, - CRONET_STATUS_ILLEGAL_STATE_STORAGE_PATH_IN_USE = -201, - CRONET_STATUS_ILLEGAL_STATE_CANNOT_SHUTDOWN_ENGINE_FROM_NETWORK_THREAD = -202, - CRONET_STATUS_ILLEGAL_STATE_ENGINE_ALREADY_STARTED = -203, - CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_STARTED = -204, - CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_INITIALIZED = -205, - CRONET_STATUS_ILLEGAL_STATE_REQUEST_ALREADY_INITIALIZED = -206, - CRONET_STATUS_ILLEGAL_STATE_REQUEST_NOT_STARTED = -207, - CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_REDIRECT = -208, - CRONET_STATUS_ILLEGAL_STATE_UNEXPECTED_READ = -209, - CRONET_STATUS_ILLEGAL_STATE_READ_FAILED = -210, - CRONET_STATUS_NULL_POINTER = -300, - CRONET_STATUS_NULL_POINTER_HOSTNAME = -301, - CRONET_STATUS_NULL_POINTER_SHA256_PINS = -302, - CRONET_STATUS_NULL_POINTER_EXPIRATION_DATE = -303, - CRONET_STATUS_NULL_POINTER_ENGINE = -304, - CRONET_STATUS_NULL_POINTER_URL = -305, - CRONET_STATUS_NULL_POINTER_CALLBACK = -306, - CRONET_STATUS_NULL_POINTER_EXECUTOR = -307, - CRONET_STATUS_NULL_POINTER_METHOD = -308, - CRONET_STATUS_NULL_POINTER_HEADER_NAME = -309, - CRONET_STATUS_NULL_POINTER_HEADER_VALUE = -310, - CRONET_STATUS_NULL_POINTER_PARAMS = -311, - CRONET_STATUS_NULL_POINTER_REQUEST_FINISHED_INFO_LISTENER_EXECUTOR = -312, +#include + +enum cronet_net_error_code { + // + // Ranges: + // 0- 99 System related errors + // 100-199 Connection related errors + // 200-299 Certificate errors + // 300-399 HTTP errors + // 400-499 Cache errors + // 500-599 ? + // 600-699 FTP errors + // 700-799 Certificate manager errors + // 800-899 DNS resolver errors + + // An asynchronous IO operation is not yet complete. This usually does not + // indicate a fatal error. Typically this error will be generated as a + // notification to wait for some external notification that the IO operation + // finally completed. + OK = 0, + CRONET_NET_ERROR_IO_PENDING = -1, + + // A generic failure occurred. + CRONET_NET_ERROR_FAILED = -2, + + // An operation was aborted (due to user action,. + CRONET_NET_ERROR_ABORTED = -3, + + // An argument to the function is incorrect. + CRONET_NET_ERROR_INVALID_ARGUMENT = -4, + + // The handle or file descriptor is invalid. + CRONET_NET_ERROR_INVALID_HANDLE = -5, + + // The file or directory cannot be found. + CRONET_NET_ERROR_FILE_NOT_FOUND = -6, + + // An operation timed out. + CRONET_NET_ERROR_TIMED_OUT = -7, + + // The file is too large. + CRONET_NET_ERROR_FILE_TOO_BIG = -8, + + // An unexpected error. This may be caused by a programming mistake or an + // invalid assumption. + CRONET_NET_ERROR_UNEXPECTED = -9, + + // Permission to access a resource = other than the network = was denied. + CRONET_NET_ERROR_ACCESS_DENIED = -10, + + // The operation failed because of unimplemented functionality. + CRONET_NET_ERROR_NOT_IMPLEMENTED = -11, + + // There were not enough resources to complete the operation. + CRONET_NET_ERROR_INSUFFICIENT_RESOURCES = -12, + + // Memory allocation failed. + CRONET_NET_ERROR_OUT_OF_MEMORY = -13, + + // The file upload failed because the file's modification time was different + // from the expectation. + CRONET_NET_ERROR_UPLOAD_FILE_CHANGED = -14, + + // The socket is not connected. + CRONET_NET_ERROR_SOCKET_NOT_CONNECTED = -15, + + // The file already exists. + CRONET_NET_ERROR_FILE_EXISTS = -16, + + // The path or file name is too long. + CRONET_NET_ERROR_FILE_PATH_TOO_LONG = -17, + + // Not enough room left on the disk. + CRONET_NET_ERROR_FILE_NO_SPACE = -18, + + // The file has a virus. + CRONET_NET_ERROR_FILE_VIRUS_INFECTED = -19, + + // The client chose to block the request. + CRONET_NET_ERROR_BLOCKED_BY_CLIENT = -20, + + // The network changed. + CRONET_NET_ERROR_NETWORK_CHANGED = -21, + + // The request was blocked by the URL block list configured by the domain + // administrator. + CRONET_NET_ERROR_BLOCKED_BY_ADMINISTRATOR = -22, + + // The socket is already connected. + CRONET_NET_ERROR_SOCKET_IS_CONNECTED = -23, + + // The request was blocked because the forced reenrollment check is still + // pending. This error can only occur on ChromeOS. + // The error can be emitted by code in + // chrome/browser/policy/policy_helpers.cc. + CRONET_NET_ERROR_BLOCKED_ENROLLMENT_CHECK_PENDING = -24, + + // The upload failed because the upload stream needed to be re-read = due to a + // retry or a redirect = but the upload stream doesn't support that operation. + CRONET_NET_ERROR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED = -25, + + // The request failed because the URLRequestContext is shutting down = or has + // been shut down. + CRONET_NET_ERROR_CONTEXT_SHUT_DOWN = -26, + + // The request failed because the response was delivered along with + // requirements + // which are not met ('X-Frame-Options' and 'Content-Security-Policy' ancestor + // checks and 'Cross-Origin-Resource-Policy' = for instance,. + CRONET_NET_ERROR_BLOCKED_BY_RESPONSE = -27, + + // Error -28 was removed (BLOCKED_BY_XSS_AUDITOR,. + + // The request was blocked by system policy disallowing some or all cleartext + // requests. Used for NetworkSecurityPolicy on Android. + CRONET_NET_ERROR_CLEARTEXT_NOT_PERMITTED = -29, + + // The request was blocked by a Content Security Policy + CRONET_NET_ERROR_BLOCKED_BY_CSP = -30, + + // The request was blocked because of no H/2 or QUIC session. + CRONET_NET_ERROR_H2_OR_QUIC_REQUIRED = -31, + + // The request was blocked because it is a private network request coming from + // an insecure context in a less private IP address space. This is used to + // enforce CORS-RFC1918: https: //wicg.github.io/cors-rfc1918. + CRONET_NET_ERROR_INSECURE_PRIVATE_NETWORK_REQUEST = -32, + + // A connection was closed (corresponding to a TCP FIN,. + CRONET_NET_ERROR_CONNECTION_CLOSED = -100, + + // A connection was reset (corresponding to a TCP RST,. + CRONET_NET_ERROR_CONNECTION_RESET = -101, + + // A connection attempt was refused. + CRONET_NET_ERROR_CONNECTION_REFUSED = -102, + + // A connection timed out as a result of not receiving an ACK for data sent. + // This can include a FIN packet that did not get ACK'd. + CRONET_NET_ERROR_CONNECTION_ABORTED = -103, + + // A connection attempt failed. + CRONET_NET_ERROR_CONNECTION_FAILED = -104, + + // The host name could not be resolved. + CRONET_NET_ERROR_NAME_NOT_RESOLVED = -105, + + // The Internet connection has been lost. + CRONET_NET_ERROR_INTERNET_DISCONNECTED = -106, + + // An SSL protocol error occurred. + CRONET_NET_ERROR_SSL_PROTOCOL_ERROR = -107, + + // The IP address or port number is invalid (e.g. = cannot connect to the IP + // address 0 or the port 0,. + CRONET_NET_ERROR_ADDRESS_INVALID = -108, + + // The IP address is unreachable. This usually means that there is no route + // to + // the specified host or network. + CRONET_NET_ERROR_ADDRESS_UNREACHABLE = -109, + + // The server requested a client certificate for SSL client authentication. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NEEDED = -110, + + // A tunnel connection through the proxy could not be established. + CRONET_NET_ERROR_TUNNEL_CONNECTION_FAILED = -111, + + // No SSL protocol versions are enabled. + CRONET_NET_ERROR_NO_SSL_VERSIONS_ENABLED = -112, + + // The client and server don't support a common SSL protocol version or + // cipher suite. + CRONET_NET_ERROR_SSL_VERSION_OR_CIPHER_MISMATCH = -113, + + // The server requested a renegotiation (rehandshake,. + CRONET_NET_ERROR_SSL_RENEGOTIATION_REQUESTED = -114, + + // The proxy requested authentication (for tunnel establishment, with an + // unsupported method. + CRONET_NET_ERROR_PROXY_AUTH_UNSUPPORTED = -115, + + // During SSL renegotiation (rehandshake, = the server sent a certificate with + // an error. + // + // Note: this error is not in the -2xx range so that it won't be handled as a + // certificate error. + CRONET_NET_ERROR_CERT_ERROR_IN_SSL_RENEGOTIATION = -116, + + // The SSL handshake failed because of a bad or missing client certificate. + CRONET_NET_ERROR_BAD_SSL_CLIENT_AUTH_CERT = -117, + + // A connection attempt timed out. + CRONET_NET_ERROR_CONNECTION_TIMED_OUT = -118, + + // There are too many pending DNS resolves = so a request in the queue was + // aborted. + CRONET_NET_ERROR_HOST_RESOLVER_QUEUE_TOO_LARGE = -119, + + // Failed establishing a connection to the SOCKS proxy server for a target + // host. + CRONET_NET_ERROR_SOCKS_CONNECTION_FAILED = -120, + + // The SOCKS proxy server failed establishing connection to the target host + // because that host is unreachable. + CRONET_NET_ERROR_SOCKS_CONNECTION_HOST_UNREACHABLE = -121, + + // The request to negotiate an alternate protocol failed. + CRONET_NET_ERROR_ALPN_NEGOTIATION_FAILED = -122, + + // The peer sent an SSL no_renegotiation alert message. + CRONET_NET_ERROR_SSL_NO_RENEGOTIATION = -123, + + // Winsock sometimes reports more data written than passed. This is probably + // due to a broken LSP. + CRONET_NET_ERROR_WINSOCK_UNEXPECTED_WRITTEN_BYTES = -124, + + // An SSL peer sent us a fatal decompression_failure alert. This typically + // occurs when a peer selects DEFLATE compression in the mistaken belief that + // it supports it. + CRONET_NET_ERROR_SSL_DECOMPRESSION_FAILURE_ALERT = -125, + + // An SSL peer sent us a fatal bad_record_mac alert. This has been observed + // from servers with buggy DEFLATE support. + CRONET_NET_ERROR_SSL_BAD_RECORD_MAC_ALERT = -126, + + // The proxy requested authentication (for tunnel establishment,. + CRONET_NET_ERROR_PROXY_AUTH_REQUESTED = -127, + + // Error -129 was removed (SSL_WEAK_SERVER_EPHEMERAL_DH_KEY,. + + // Could not create a connection to the proxy server. An error occurred + // either in resolving its name = or in connecting a socket to it. + // Note that this does NOT include failures during the actual "CONNECT" method + // of an HTTP proxy. + CRONET_NET_ERROR_PROXY_CONNECTION_FAILED = -130, + + // A mandatory proxy configuration could not be used. Currently this means + // that a mandatory PAC script could not be fetched = parsed or executed. + CRONET_NET_ERROR_MANDATORY_PROXY_CONFIGURATION_FAILED = -131, + + // -132 was formerly ERR_ESET_ANTI_VIRUS_SSL_INTERCEPTION + + // We've hit the max socket limit for the socket pool while preconnecting. We + // don't bother trying to preconnect more sockets. + CRONET_NET_ERROR_PRECONNECT_MAX_SOCKET_LIMIT = -133, + + // The permission to use the SSL client certificate's private key was denied. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED = -134, + + // The SSL client certificate has no private key. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY = -135, + + // The certificate presented by the HTTPS Proxy was invalid. + CRONET_NET_ERROR_PROXY_CERTIFICATE_INVALID = -136, + + // An error occurred when trying to do a name resolution (DNS,. + CRONET_NET_ERROR_NAME_RESOLUTION_FAILED = -137, + + // Permission to access the network was denied. This is used to distinguish + // errors that were most likely caused by a firewall from other access denied + // errors. See also ERR_ACCESS_DENIED. + CRONET_NET_ERROR_NETWORK_ACCESS_DENIED = -138, + + // The request throttler module cancelled this request to avoid DDOS. + CRONET_NET_ERROR_TEMPORARILY_THROTTLED = -139, + + // A request to create an SSL tunnel connection through the HTTPS proxy + // received a 302 (temporary redirect, response. The response body might + // include a description of why the request failed. + // + // TODO(https: //crbug.com/928551,: This is deprecated and should not be used + // by + // new code. + CRONET_NET_ERROR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT = -140, + + // We were unable to sign the CertificateVerify data of an SSL client auth + // handshake with the client certificate's private key. + // + // Possible causes for this include the user implicitly or explicitly + // denying access to the private key = the private key may not be valid for + // signing = the key may be relying on a cached handle which is no longer + // valid = or the CSP won't allow arbitrary data to be signed. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_SIGNATURE_FAILED = -141, + + // The message was too large for the transport. (for example a UDP message + // which exceeds size threshold,. + CRONET_NET_ERROR_MSG_TOO_BIG = -142, + + // Error -143 was removed (SPDY_SESSION_ALREADY_EXISTS, + + // Error -144 was removed (LIMIT_VIOLATION,. + + // Websocket protocol error. Indicates that we are terminating the connection + // due to a malformed frame or other protocol violation. + CRONET_NET_ERROR_WS_PROTOCOL_ERROR = -145, + + // Error -146 was removed (PROTOCOL_SWITCHED, + + // Returned when attempting to bind an address that is already in use. + CRONET_NET_ERROR_ADDRESS_IN_USE = -147, + + // An operation failed because the SSL handshake has not completed. + CRONET_NET_ERROR_SSL_HANDSHAKE_NOT_COMPLETED = -148, + + // SSL peer's public key is invalid. + CRONET_NET_ERROR_SSL_BAD_PEER_PUBLIC_KEY = -149, + + // The certificate didn't match the built-in public key pins for the host + // name. + // The pins are set in net/http/transport_security_state.cc and require that + // one of a set of public keys exist on the path from the leaf to the root. + CRONET_NET_ERROR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN = -150, + + // Server request for client certificate did not contain any types we support. + CRONET_NET_ERROR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED = -151, + + // Error -152 was removed (ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH, + + // An SSL peer sent us a fatal decrypt_error alert. This typically occurs when + // a peer could not correctly verify a signature (in CertificateVerify or + // ServerKeyExchange, or validate a Finished message. + CRONET_NET_ERROR_SSL_DECRYPT_ERROR_ALERT = -153, + + // There are too many pending WebSocketJob instances = so the new job was not + // pushed to the queue. + CRONET_NET_ERROR_WS_THROTTLE_QUEUE_TOO_LARGE = -154, + + // Error -155 was removed (TOO_MANY_SOCKET_STREAMS, + + // The SSL server certificate changed in a renegotiation. + CRONET_NET_ERROR_SSL_SERVER_CERT_CHANGED = -156, + + // Error -157 was removed (SSL_INAPPROPRIATE_FALLBACK,. + + // Error -158 was removed (CT_NO_SCTS_VERIFIED_OK,. + + // The SSL server sent us a fatal unrecognized_name alert. + CRONET_NET_ERROR_SSL_UNRECOGNIZED_NAME_ALERT = -159, + + // Failed to set the socket's receive buffer size as requested. + CRONET_NET_ERROR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR = -160, + + // Failed to set the socket's send buffer size as requested. + CRONET_NET_ERROR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR = -161, + + // Failed to set the socket's receive buffer size as requested = despite + // success + // return code from setsockopt. + CRONET_NET_ERROR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE = -162, + + // Failed to set the socket's send buffer size as requested = despite success + // return code from setsockopt. + CRONET_NET_ERROR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE = -163, + + // Failed to import a client certificate from the platform store into the SSL + // library. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT = -164, + + // Error -165 was removed (SSL_FALLBACK_BEYOND_MINIMUM_VERSION,. + + // Resolving a hostname to an IP address list included the IPv4 address + // "127.0.53.53". This is a special IP address which ICANN has recommended to + // indicate there was a name collision = and alert admins to a potential + // problem. + CRONET_NET_ERROR_ICANN_NAME_COLLISION = -166, + + // The SSL server presented a certificate which could not be decoded. This is + // not a certificate error code as no X509Certificate object is available. + // This + // error is fatal. + CRONET_NET_ERROR_SSL_SERVER_CERT_BAD_FORMAT = -167, + + // Certificate Transparency: Received a signed tree head that failed to parse. + CRONET_NET_ERROR_CT_STH_PARSING_FAILED = -168, + + // Certificate Transparency: Received a signed tree head whose JSON parsing + // was + // OK but was missing some of the fields. + CRONET_NET_ERROR_CT_STH_INCOMPLETE = -169, + + // The attempt to reuse a connection to send proxy auth credentials failed + // before the AuthController was used to generate credentials. The caller + // should + // reuse the controller with a new connection. This error is only used + // internally by the network stack. + CRONET_NET_ERROR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH = -170, + + // Certificate Transparency: Failed to parse the received consistency proof. + CRONET_NET_ERROR_CT_CONSISTENCY_PROOF_PARSING_FAILED = -171, + + // The SSL server required an unsupported cipher suite that has since been + // removed. This error will temporarily be signaled on a fallback for one or + // two + // releases immediately following a cipher suite's removal = after which the + // fallback will be removed. + CRONET_NET_ERROR_SSL_OBSOLETE_CIPHER = -172, + + // When a WebSocket handshake is done successfully and the connection has been + // upgraded = the URLRequest is cancelled with this error code. + CRONET_NET_ERROR_WS_UPGRADE = -173, + + // Socket ReadIfReady support is not implemented. This error should not be + // user + // visible = because the normal Read(, method is used as a fallback. + CRONET_NET_ERROR_READ_IF_READY_NOT_IMPLEMENTED = -174, + + // Error -175 was removed (SSL_VERSION_INTERFERENCE,. + + // No socket buffer space is available. + CRONET_NET_ERROR_NO_BUFFER_SPACE = -176, + + // There were no common signature algorithms between our client certificate + // private key and the server's preferences. + CRONET_NET_ERROR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS = -177, + + // TLS 1.3 early data was rejected by the server. This will be received before + // any data is returned from the socket. The request should be retried with + // early data disabled. + CRONET_NET_ERROR_EARLY_DATA_REJECTED = -178, + + // TLS 1.3 early data was offered = but the server responded with TLS 1.2 or + // earlier. This is an internal error code to account for a + // backwards-compatibility issue with early data and TLS 1.2. It will be + // received before any data is returned from the socket. The request should be + // retried with early data disabled. + // + // See https: //tools.ietf.org/html/rfc8446#appendix-D.3 for details. + CRONET_NET_ERROR_WRONG_VERSION_ON_EARLY_DATA = -179, + + // TLS 1.3 was enabled = but a lower version was negotiated and the server + // returned a value indicating it supported TLS 1.3. This is part of a + // security + // check in TLS 1.3 = but it may also indicate the user is behind a buggy + // TLS-terminating proxy which implemented TLS 1.2 incorrectly. (See + // https: //crbug.com/boringssl/226., + CRONET_NET_ERROR_TLS13_DOWNGRADE_DETECTED = -180, + + // The server's certificate has a keyUsage extension incompatible with the + // negotiated TLS key exchange method. + CRONET_NET_ERROR_SSL_KEY_USAGE_INCOMPATIBLE = -181, + + // Certificate error codes + // + // The values of certificate error codes must be consecutive. + + // The server responded with a certificate whose common name did not match + // the host name. This could mean: + // + // 1. An attacker has redirected our traffic to their server and is + // presenting a certificate for which they know the private key. + // + // 2. The server is misconfigured and responding with the wrong cert. + // + // 3. The user is on a wireless network and is being redirected to the + // network's login page. + // + // 4. The OS has used a DNS search suffix and the server doesn't have + // a certificate for the abbreviated name in the address bar. + // + CRONET_NET_ERROR_CERT_COMMON_NAME_INVALID = -200, + + // The server responded with a certificate that = by our clock = appears to + // either not yet be valid or to have expired. This could mean: + // + // 1. An attacker is presenting an old certificate for which they have + // managed to obtain the private key. + // + // 2. The server is misconfigured and is not presenting a valid cert. + // + // 3. Our clock is wrong. + // + CRONET_NET_ERROR_CERT_DATE_INVALID = -201, + + // The server responded with a certificate that is signed by an authority + // we don't trust. The could mean: + // + // 1. An attacker has substituted the real certificate for a cert that + // contains their public key and is signed by their cousin. + // + // 2. The server operator has a legitimate certificate from a CA we don't + // know about = but should trust. + // + // 3. The server is presenting a self-signed certificate = providing no + // defense against active attackers (but foiling passive attackers,. + // + CRONET_NET_ERROR_CERT_AUTHORITY_INVALID = -202, + + // The server responded with a certificate that contains errors. + // This error is not recoverable. + // + // MSDN describes this error as follows: + // "The SSL certificate contains errors." + // NOTE: It's unclear how this differs from ERR_CERT_INVALID. For consistency + // = + // use that code instead of this one from now on. + // + CRONET_NET_ERROR_CERT_CONTAINS_ERRORS = -203, + + // The certificate has no mechanism for determining if it is revoked. In + // effect = this certificate cannot be revoked. + CRONET_NET_ERROR_CERT_NO_REVOCATION_MECHANISM = -204, + + // Revocation information for the security certificate for this site is not + // available. This could mean: + // + // 1. An attacker has compromised the private key in the certificate and is + // blocking our attempt to find out that the cert was revoked. + // + // 2. The certificate is unrevoked = but the revocation server is busy or + // unavailable. + // + CRONET_NET_ERROR_CERT_UNABLE_TO_CHECK_REVOCATION = -205, + + // The server responded with a certificate has been revoked. + // We have the capability to ignore this error = but it is probably not the + // thing to do. + CRONET_NET_ERROR_CERT_REVOKED = -206, + + // The server responded with a certificate that is invalid. + // This error is not recoverable. + // + // MSDN describes this error as follows: + // "The SSL certificate is invalid." + // + CRONET_NET_ERROR_CERT_INVALID = -207, + + // The server responded with a certificate that is signed using a weak + // signature algorithm. + CRONET_NET_ERROR_CERT_WEAK_SIGNATURE_ALGORITHM = -208, + + // -209 is availible: was CERT_NOT_IN_DNS. + + // The host name specified in the certificate is not unique. + CRONET_NET_ERROR_CERT_NON_UNIQUE_NAME = -210, + + // The server responded with a certificate that contains a weak key (e.g. + // a too-small RSA key,. + CRONET_NET_ERROR_CERT_WEAK_KEY = -211, + + // The certificate claimed DNS names that are in violation of name + // constraints. + CRONET_NET_ERROR_CERT_NAME_CONSTRAINT_VIOLATION = -212, + + // The certificate's validity period is too long. + CRONET_NET_ERROR_CERT_VALIDITY_TOO_LONG = -213, + + // Certificate Transparency was required for this connection = but the server + // did not provide CT information that complied with the policy. + CRONET_NET_ERROR_CERTIFICATE_TRANSPARENCY_REQUIRED = -214, + + // The certificate chained to a legacy Symantec root that is no longer + // trusted. + // https: //g.co/chrome/symantecpkicerts + CRONET_NET_ERROR_CERT_SYMANTEC_LEGACY = -215, + + // -216 was QUIC_CERT_ROOT_NOT_KNOWN which has been renumbered to not be in + // the + // certificate error range. + + // The certificate is known to be used for interception by an entity other + // the device owner. + CRONET_NET_ERROR_CERT_KNOWN_INTERCEPTION_BLOCKED = -217, + + // The connection uses an obsolete version of SSL/TLS. + CRONET_NET_ERROR_SSL_OBSOLETE_VERSION = -218, + + // Add new certificate error codes here. + // + // Update the value of CERT_END whenever you add a new certificate error + // code. + + // The value immediately past the last certificate error code. + CRONET_NET_ERROR_CERT_END = -219, + + // The URL is invalid. + CRONET_NET_ERROR_INVALID_URL = -300, + + // The scheme of the URL is disallowed. + CRONET_NET_ERROR_DISALLOWED_URL_SCHEME = -301, + + // The scheme of the URL is unknown. + CRONET_NET_ERROR_UNKNOWN_URL_SCHEME = -302, + + // Attempting to load an URL resulted in a redirect to an invalid URL. + CRONET_NET_ERROR_INVALID_REDIRECT = -303, + + // Attempting to load an URL resulted in too many redirects. + CRONET_NET_ERROR_TOO_MANY_REDIRECTS = -310, + + // Attempting to load an URL resulted in an unsafe redirect (e.g. = a redirect + // to file: // is considered unsafe,. + CRONET_NET_ERROR_UNSAFE_REDIRECT = -311, + + // Attempting to load an URL with an unsafe port number. These are port + // numbers that correspond to services = which are not robust to spurious + // input + // that may be constructed as a result of an allowed web construct (e.g. = + // HTTP + // looks a lot like SMTP = so form submission to port 25 is denied,. + CRONET_NET_ERROR_UNSAFE_PORT = -312, + + // The server's response was invalid. + CRONET_NET_ERROR_INVALID_RESPONSE = -320, + + // Error in chunked transfer encoding. + CRONET_NET_ERROR_INVALID_CHUNKED_ENCODING = -321, + + // The server did not support the request method. + CRONET_NET_ERROR_METHOD_NOT_SUPPORTED = -322, + + // The response was 407 (Proxy Authentication Required, = yet we did not send + // the request to a proxy. + CRONET_NET_ERROR_UNEXPECTED_PROXY_AUTH = -323, + + // The server closed the connection without sending any data. + CRONET_NET_ERROR_EMPTY_RESPONSE = -324, + + // The headers section of the response is too large. + CRONET_NET_ERROR_RESPONSE_HEADERS_TOO_BIG = -325, + + // Error -326 was removed (PAC_STATUS_NOT_OK, + + // The evaluation of the PAC script failed. + CRONET_NET_ERROR_PAC_SCRIPT_FAILED = -327, + + // The response was 416 (Requested range not satisfiable, and the server + // cannot + // satisfy the range requested. + CRONET_NET_ERROR_REQUEST_RANGE_NOT_SATISFIABLE = -328, + + // The identity used for authentication is invalid. + CRONET_NET_ERROR_MALFORMED_IDENTITY = -329, + + // Content decoding of the response body failed. + CRONET_NET_ERROR_CONTENT_DECODING_FAILED = -330, + + // An operation could not be completed because all network IO + // is suspended. + CRONET_NET_ERROR_NETWORK_IO_SUSPENDED = -331, + + // FLIP data received without receiving a SYN_REPLY on the stream. + CRONET_NET_ERROR_SYN_REPLY_NOT_RECEIVED = -332, + + // Converting the response to target encoding failed. + CRONET_NET_ERROR_ENCODING_CONVERSION_FAILED = -333, + + // The server sent an FTP directory listing in a format we do not understand. + CRONET_NET_ERROR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT = -334, + + // Obsolete. Was only logged in NetLog when an HTTP/2 pushed stream expired. + // CRONET_NET_ERROR_INVALID_SPDY_STREAM = -335, + + // There are no supported proxies in the provided list. + CRONET_NET_ERROR_NO_SUPPORTED_PROXIES = -336, + + // There is an HTTP/2 protocol error. + CRONET_NET_ERROR_HTTP2_PROTOCOL_ERROR = -337, + + // Credentials could not be established during HTTP Authentication. + CRONET_NET_ERROR_INVALID_AUTH_CREDENTIALS = -338, + + // An HTTP Authentication scheme was tried which is not supported on this + // machine. + CRONET_NET_ERROR_UNSUPPORTED_AUTH_SCHEME = -339, + + // Detecting the encoding of the response failed. + CRONET_NET_ERROR_ENCODING_DETECTION_FAILED = -340, + + // (GSSAPI, No Kerberos credentials were available during HTTP Authentication. + CRONET_NET_ERROR_MISSING_AUTH_CREDENTIALS = -341, + + // An unexpected = but documented = SSPI or GSSAPI status code was returned. + CRONET_NET_ERROR_UNEXPECTED_SECURITY_LIBRARY_STATUS = -342, + + // The environment was not set up correctly for authentication (for + // example = no KDC could be found or the principal is unknown. + CRONET_NET_ERROR_MISCONFIGURED_AUTH_ENVIRONMENT = -343, + + // An undocumented SSPI or GSSAPI status code was returned. + CRONET_NET_ERROR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS = -344, + + // The HTTP response was too big to drain. + CRONET_NET_ERROR_RESPONSE_BODY_TOO_BIG_TO_DRAIN = -345, + + // The HTTP response contained multiple distinct Content-Length headers. + CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH = -346, + + // HTTP/2 headers have been received = but not all of them - status or version + // headers are missing = so we're expecting additional frames to complete + // them. + CRONET_NET_ERROR_INCOMPLETE_HTTP2_HEADERS = -347, + + // No PAC URL configuration could be retrieved from DHCP. This can indicate + // either a failure to retrieve the DHCP configuration = or that there was no + // PAC URL configured in DHCP. + CRONET_NET_ERROR_PAC_NOT_IN_DHCP = -348, + + // The HTTP response contained multiple Content-Disposition headers. + CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION = -349, + + // The HTTP response contained multiple Location headers. + CRONET_NET_ERROR_RESPONSE_HEADERS_MULTIPLE_LOCATION = -350, + + // HTTP/2 server refused the request without processing = and sent either a + // GOAWAY frame with error code NO_ERROR and Last-Stream-ID lower than the + // stream id corresponding to the request indicating that this request has not + // been processed yet = or a RST_STREAM frame with error code REFUSED_STREAM. + // Client MAY retry (on a different connection,. See RFC7540 Section 8.1.4. + CRONET_NET_ERROR_HTTP2_SERVER_REFUSED_STREAM = -351, + + // HTTP/2 server didn't respond to the PING message. + CRONET_NET_ERROR_HTTP2_PING_FAILED = -352, + + // Obsolete. Kept here to avoid reuse = as the old error can still appear on + // histograms. + // CRONET_NET_ERROR_PIPELINE_EVICTION = -353, + + // The HTTP response body transferred fewer bytes than were advertised by the + // Content-Length header when the connection is closed. + CRONET_NET_ERROR_CONTENT_LENGTH_MISMATCH = -354, + + // The HTTP response body is transferred with Chunked-Encoding = but the + // terminating zero-length chunk was never sent when the connection is closed. + CRONET_NET_ERROR_INCOMPLETE_CHUNKED_ENCODING = -355, + + // There is a QUIC protocol error. + CRONET_NET_ERROR_QUIC_PROTOCOL_ERROR = -356, + + // The HTTP headers were truncated by an EOF. + CRONET_NET_ERROR_RESPONSE_HEADERS_TRUNCATED = -357, + + // The QUIC crytpo handshake failed. This means that the server was unable + // to read any requests sent = so they may be resent. + CRONET_NET_ERROR_QUIC_HANDSHAKE_FAILED = -358, + + // Obsolete. Kept here to avoid reuse = as the old error can still appear on + // histograms. + // CRONET_NET_ERROR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC = -359, + + // Transport security is inadequate for the HTTP/2 version. + CRONET_NET_ERROR_HTTP2_INADEQUATE_TRANSPORT_SECURITY = -360, + + // The peer violated HTTP/2 flow control. + CRONET_NET_ERROR_HTTP2_FLOW_CONTROL_ERROR = -361, + + // The peer sent an improperly sized HTTP/2 frame. + CRONET_NET_ERROR_HTTP2_FRAME_SIZE_ERROR = -362, + + // Decoding or encoding of compressed HTTP/2 headers failed. + CRONET_NET_ERROR_HTTP2_COMPRESSION_ERROR = -363, + + // Proxy Auth Requested without a valid Client Socket Handle. + CRONET_NET_ERROR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION = -364, + + // HTTP_1_1_REQUIRED error code received on HTTP/2 session. + CRONET_NET_ERROR_HTTP_1_1_REQUIRED = -365, + + // HTTP_1_1_REQUIRED error code received on HTTP/2 session to proxy. + CRONET_NET_ERROR_PROXY_HTTP_1_1_REQUIRED = -366, + + // The PAC script terminated fatally and must be reloaded. + CRONET_NET_ERROR_PAC_SCRIPT_TERMINATED = -367, + + // Obsolete. Kept here to avoid reuse. + // Request is throttled because of a Backoff header. + // See: crbug.com/486891. + // CRONET_NET_ERROR_TEMPORARY_BACKOFF = -369, + + // The server was expected to return an HTTP/1.x response = but did not. + // Rather + // than treat it as HTTP/0.9 = this error is returned. + CRONET_NET_ERROR_INVALID_HTTP_RESPONSE = -370, + + // Initializing content decoding failed. + CRONET_NET_ERROR_CONTENT_DECODING_INIT_FAILED = -371, + + // Received HTTP/2 RST_STREAM frame with NO_ERROR error code. This error + // should + // be handled internally by HTTP/2 code = and should not make it above the + // SpdyStream layer. + CRONET_NET_ERROR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED = -372, + + // The pushed stream claimed by the request is no longer available. + CRONET_NET_ERROR_HTTP2_PUSHED_STREAM_NOT_AVAILABLE = -373, + + // A pushed stream was claimed and later reset by the server. When this + // happens = + // the request should be retried. + CRONET_NET_ERROR_HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER = -374, + + // An HTTP transaction was retried too many times due for authentication or + // invalid certificates. This may be due to a bug in the net stack that would + // otherwise infinite loop = or if the server or proxy continually requests + // fresh + // credentials or presents a fresh invalid certificate. + CRONET_NET_ERROR_TOO_MANY_RETRIES = -375, + + // Received an HTTP/2 frame on a closed stream. + CRONET_NET_ERROR_HTTP2_STREAM_CLOSED = -376, + + // Client is refusing an HTTP/2 stream. + CRONET_NET_ERROR_HTTP2_CLIENT_REFUSED_STREAM = -377, + + // A pushed HTTP/2 stream was claimed by a request based on matching URL and + // request headers = but the pushed response headers do not match the request. + CRONET_NET_ERROR_HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH = -378, + + // The server returned a non-2xx HTTP response code. + // + // Not that this error is only used by certain APIs that interpret the HTTP + // response itself. URLRequest for instance just passes most non-2xx + // response back as success. + CRONET_NET_ERROR_HTTP_RESPONSE_CODE_FAILURE = -379, + + // The certificate presented on a QUIC connection does not chain to a known + // root + // and the origin connected to is not on a list of domains where unknown roots + // are allowed. + CRONET_NET_ERROR_QUIC_CERT_ROOT_NOT_KNOWN = -380, + + // The cache does not have the requested entry. + CRONET_NET_ERROR_CACHE_MISS = -400, + + // Unable to read from the disk cache. + CRONET_NET_ERROR_CACHE_READ_FAILURE = -401, + + // Unable to write to the disk cache. + CRONET_NET_ERROR_CACHE_WRITE_FAILURE = -402, + + // The operation is not supported for this entry. + CRONET_NET_ERROR_CACHE_OPERATION_NOT_SUPPORTED = -403, + + // The disk cache is unable to open this entry. + CRONET_NET_ERROR_CACHE_OPEN_FAILURE = -404, + + // The disk cache is unable to create this entry. + CRONET_NET_ERROR_CACHE_CREATE_FAILURE = -405, + + // Multiple transactions are racing to create disk cache entries. This is an + // internal error returned from the HttpCache to the HttpCacheTransaction that + // tells the transaction to restart the entry-creation logic because the state + // of the cache has changed. + CRONET_NET_ERROR_CACHE_RACE = -406, + + // The cache was unable to read a checksum record on an entry. This can be + // returned from attempts to read from the cache. It is an internal error = + // returned by the SimpleCache backend = but not by any URLRequest methods + // or members. + CRONET_NET_ERROR_CACHE_CHECKSUM_READ_FAILURE = -407, + + // The cache found an entry with an invalid checksum. This can be returned + // from + // attempts to read from the cache. It is an internal error = returned by the + // SimpleCache backend = but not by any URLRequest methods or members. + CRONET_NET_ERROR_CACHE_CHECKSUM_MISMATCH = -408, + + // Internal error code for the HTTP cache. The cache lock timeout has fired. + CRONET_NET_ERROR_CACHE_LOCK_TIMEOUT = -409, + + // Received a challenge after the transaction has read some data = and the + // credentials aren't available. There isn't a way to get them at that point. + CRONET_NET_ERROR_CACHE_AUTH_FAILURE_AFTER_READ = -410, + + // Internal not-quite error code for the HTTP cache. In-memory hints suggest + // that the cache entry would not have been useable with the transaction's + // current configuration (e.g. load flags = mode = etc., + CRONET_NET_ERROR_CACHE_ENTRY_NOT_SUITABLE = -411, + + // The disk cache is unable to doom this entry. + CRONET_NET_ERROR_CACHE_DOOM_FAILURE = -412, + + // The disk cache is unable to open or create this entry. + CRONET_NET_ERROR_CACHE_OPEN_OR_CREATE_FAILURE = -413, + + // The server's response was insecure (e.g. there was a cert error,. + CRONET_NET_ERROR_INSECURE_RESPONSE = -501, + + // An attempt to import a client certificate failed = as the user's key + // database lacked a corresponding private key. + CRONET_NET_ERROR_NO_PRIVATE_KEY_FOR_CERT = -502, + + // An error adding a certificate to the OS certificate database. + CRONET_NET_ERROR_ADD_USER_CERT_FAILED = -503, + + // An error occurred while handling a signed exchange. + CRONET_NET_ERROR_INVALID_SIGNED_EXCHANGE = -504, + + // An error occurred while handling a Web Bundle source. + CRONET_NET_ERROR_INVALID_WEB_BUNDLE = -505, + + // A Trust Tokens protocol operation-executing request failed for one of a + // number of reasons (precondition failure = internal error = bad response,. + CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_FAILED = -506, + + // When handling a Trust Tokens protocol operation-executing request = the + // system + // found that the request's desired Trust Tokens results were already present + // in + // a local cache; as a result = the main request was cancelled. + CRONET_NET_ERROR_TRUST_TOKEN_OPERATION_CACHE_HIT = -507, + + // *** Code -600 is reserved (was FTP_PASV_COMMAND_FAILED,. *** + + // A generic error for failed FTP control connection command. + // If possible = please use or add a more specific error code. + CRONET_NET_ERROR_FTP_FAILED = -601, + + // The server cannot fulfill the request at this point. This is a temporary + // error. + // FTP response code 421. + CRONET_NET_ERROR_FTP_SERVICE_UNAVAILABLE = -602, + + // The server has aborted the transfer. + // FTP response code 426. + CRONET_NET_ERROR_FTP_TRANSFER_ABORTED = -603, + + // The file is busy = or some other temporary error condition on opening + // the file. + // FTP response code 450. + CRONET_NET_ERROR_FTP_FILE_BUSY = -604, + + // Server rejected our command because of syntax errors. + // FTP response codes 500 = 501. + CRONET_NET_ERROR_FTP_SYNTAX_ERROR = -605, + + // Server does not support the command we issued. + // FTP response codes 502 = 504. + CRONET_NET_ERROR_FTP_COMMAND_NOT_SUPPORTED = -606, + + // Server rejected our command because we didn't issue the commands in right + // order. + // FTP response code 503. + CRONET_NET_ERROR_FTP_BAD_COMMAND_SEQUENCE = -607, + + // PKCS #12 import failed due to incorrect password. + CRONET_NET_ERROR_PKCS12_IMPORT_BAD_PASSWORD = -701, + + // PKCS #12 import failed due to other error. + CRONET_NET_ERROR_PKCS12_IMPORT_FAILED = -702, + + // CA import failed - not a CA cert. + CRONET_NET_ERROR_IMPORT_CA_CERT_NOT_CA = -703, + + // Import failed - certificate already exists in database. + // Note it's a little weird this is an error but reimporting a PKCS12 is ok + // (no-op,. That's how Mozilla does it = though. + CRONET_NET_ERROR_IMPORT_CERT_ALREADY_EXISTS = -704, + + // CA import failed due to some other error. + CRONET_NET_ERROR_IMPORT_CA_CERT_FAILED = -705, + + // Server certificate import failed due to some internal error. + CRONET_NET_ERROR_IMPORT_SERVER_CERT_FAILED = -706, + + // PKCS #12 import failed due to invalid MAC. + CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_MAC = -707, + + // PKCS #12 import failed due to invalid/corrupt file. + CRONET_NET_ERROR_PKCS12_IMPORT_INVALID_FILE = -708, + + // PKCS #12 import failed due to unsupported features. + CRONET_NET_ERROR_PKCS12_IMPORT_UNSUPPORTED = -709, + + // Key generation failed. + CRONET_NET_ERROR_KEY_GENERATION_FAILED = -710, + + // Error -711 was removed (ORIGIN_BOUND_CERT_GENERATION_FAILED, + + // Failure to export private key. + CRONET_NET_ERROR_PRIVATE_KEY_EXPORT_FAILED = -712, + + // Self-signed certificate generation failed. + CRONET_NET_ERROR_SELF_SIGNED_CERT_GENERATION_FAILED = -713, + + // The certificate database changed in some way. + CRONET_NET_ERROR_CERT_DATABASE_CHANGED = -714, + + // Error -715 was removed (CHANNEL_ID_IMPORT_FAILED, + + // DNS error codes. + + // DNS resolver received a malformed response. + CRONET_NET_ERROR_DNS_MALFORMED_RESPONSE = -800, + + // DNS server requires TCP + CRONET_NET_ERROR_DNS_SERVER_REQUIRES_TCP = -801, + + // DNS server failed. This error is returned for all of the following + // error conditions: + // 1 - Format error - The name server was unable to interpret the query. + // 2 - Server failure - The name server was unable to process this query + // due to a problem with the name server. + // 4 - Not Implemented - The name server does not support the requested + // kind of query. + // 5 - Refused - The name server refuses to perform the specified + // operation for policy reasons. + CRONET_NET_ERROR_DNS_SERVER_FAILED = -802, + + // DNS transaction timed out. + CRONET_NET_ERROR_DNS_TIMED_OUT = -803, + + // The entry was not found in cache or other local sources = for lookups where + // only local sources were queried. + CRONET_NET_ERROR_DNS_CACHE_MISS = -804, + + // Suffix search list rules prevent resolution of the given host name. + CRONET_NET_ERROR_DNS_SEARCH_EMPTY = -805, + + // Failed to sort addresses according to RFC3484. + CRONET_NET_ERROR_DNS_SORT_ERROR = -806, + + // Error -807 was removed (DNS_HTTP_FAILED, + + // Failed to resolve the hostname of a DNS-over-HTTPS server. + CRONET_NET_ERROR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED = -808, }; -const char* cronet_status_as_string(cronet_status_code status); +const char* cronet_net_error_as_string(cronet_net_error_code net_error); #endif /* GRPC_CORE_EXT_TRANSPORT_CRONET_TRANSPORT_CRONET_STATUS_H */ diff --git a/src/core/ext/transport/cronet/transport/cronet_transport.cc b/src/core/ext/transport/cronet/transport/cronet_transport.cc index 8f845118678..d092b90b161 100644 --- a/src/core/ext/transport/cronet/transport/cronet_transport.cc +++ b/src/core/ext/transport/cronet/transport/cronet_transport.cc @@ -23,6 +23,7 @@ #include #include "absl/strings/str_cat.h" +#include "absl/strings/str_format.h" #include #include @@ -163,7 +164,7 @@ struct op_state { bool pending_send_message = false; /* User requested RECV_TRAILING_METADATA */ bool pending_recv_trailing_metadata = false; - cronet_status_code net_error = CRONET_STATUS_SUCCESS; + cronet_net_error_code net_error = OK; grpc_error* cancel_error = GRPC_ERROR_NONE; /* data structure for storing data coming from server */ struct read_state rs; @@ -305,8 +306,14 @@ static void read_grpc_header(stream_obj* s) { s->state.rs.remaining_bytes); } -static grpc_error* make_error_with_desc(int error_code, const char* desc) { - grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(desc); +static grpc_error* make_error_with_desc(int error_code, + int cronet_internal_error_code, + const char* desc) { + std::string error_message = + absl::StrFormat("Cronet error code:%d, Cronet error detail:%s", + cronet_internal_error_code, desc); + grpc_error* error = + GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_message.c_str()); error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS, error_code); return error; } @@ -434,7 +441,7 @@ static void on_failed(bidirectional_stream* stream, int net_error) { gpr_mu_lock(&s->mu); bidirectional_stream_destroy(s->cbs); s->state.state_callback_received[OP_FAILED] = true; - s->state.net_error = static_cast(net_error); + s->state.net_error = static_cast(net_error); s->cbs = nullptr; if (s->header_array.headers) { gpr_free(s->header_array.headers); @@ -1297,9 +1304,9 @@ static enum e_op_result execute_stream_op(struct op_and_state* oas) { if (stream_state->state_op_done[OP_CANCEL_ERROR]) { error = GRPC_ERROR_REF(stream_state->cancel_error); } else if (stream_state->state_callback_received[OP_FAILED]) { - const char* error_message = - cronet_status_as_string(stream_state->net_error); - error = make_error_with_desc(GRPC_STATUS_UNAVAILABLE, error_message); + const char* desc = cronet_net_error_as_string(stream_state->net_error); + error = make_error_with_desc(GRPC_STATUS_UNAVAILABLE, + stream_state->net_error, desc); } else if (oas->s->state.rs.trailing_metadata_valid) { grpc_chttp2_incoming_metadata_buffer_publish( &oas->s->state.rs.trailing_metadata, @@ -1337,10 +1344,11 @@ static enum e_op_result execute_stream_op(struct op_and_state* oas) { } else if (stream_state->state_callback_received[OP_FAILED]) { if (stream_op->on_complete) { const char* error_message = - cronet_status_as_string(stream_state->net_error); + cronet_net_error_as_string(stream_state->net_error); grpc_core::ExecCtx::Run( DEBUG_LOCATION, stream_op->on_complete, - make_error_with_desc(GRPC_STATUS_UNAVAILABLE, error_message)); + make_error_with_desc(GRPC_STATUS_UNAVAILABLE, + stream_state->net_error, error_message)); } } else { /* All actions in this stream_op are complete. Call the on_complete