| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // This file intentionally does not have header guards, it's included | |
| 6 // inside a macro to generate enum values. | |
| 7 | |
| 8 // This file contains the list of network errors. | |
| 9 | |
| 10 // | |
| 11 // Ranges: | |
| 12 // 0- 99 System related errors | |
| 13 // 100-199 Connection related errors | |
| 14 // 200-299 Certificate errors | |
| 15 // 300-399 HTTP errors | |
| 16 // 400-499 Cache errors | |
| 17 // 500-599 ? | |
| 18 // 600-699 FTP errors | |
| 19 // 700-799 Certificate manager errors | |
| 20 // 800-899 DNS resolver errors | |
| 21 | |
| 22 // An asynchronous IO operation is not yet complete. This usually does not | |
| 23 // indicate a fatal error. Typically this error will be generated as a | |
| 24 // notification to wait for some external notification that the IO operation | |
| 25 // finally completed. | |
| 26 NET_ERROR(IO_PENDING, -1) | |
| 27 | |
| 28 // A generic failure occurred. | |
| 29 NET_ERROR(FAILED, -2) | |
| 30 | |
| 31 // An operation was aborted (due to user action). | |
| 32 NET_ERROR(ABORTED, -3) | |
| 33 | |
| 34 // An argument to the function is incorrect. | |
| 35 NET_ERROR(INVALID_ARGUMENT, -4) | |
| 36 | |
| 37 // The handle or file descriptor is invalid. | |
| 38 NET_ERROR(INVALID_HANDLE, -5) | |
| 39 | |
| 40 // The file or directory cannot be found. | |
| 41 NET_ERROR(FILE_NOT_FOUND, -6) | |
| 42 | |
| 43 // An operation timed out. | |
| 44 NET_ERROR(TIMED_OUT, -7) | |
| 45 | |
| 46 // The file is too large. | |
| 47 NET_ERROR(FILE_TOO_BIG, -8) | |
| 48 | |
| 49 // An unexpected error. This may be caused by a programming mistake or an | |
| 50 // invalid assumption. | |
| 51 NET_ERROR(UNEXPECTED, -9) | |
| 52 | |
| 53 // Permission to access a resource, other than the network, was denied. | |
| 54 NET_ERROR(ACCESS_DENIED, -10) | |
| 55 | |
| 56 // The operation failed because of unimplemented functionality. | |
| 57 NET_ERROR(NOT_IMPLEMENTED, -11) | |
| 58 | |
| 59 // There were not enough resources to complete the operation. | |
| 60 NET_ERROR(INSUFFICIENT_RESOURCES, -12) | |
| 61 | |
| 62 // Memory allocation failed. | |
| 63 NET_ERROR(OUT_OF_MEMORY, -13) | |
| 64 | |
| 65 // The file upload failed because the file's modification time was different | |
| 66 // from the expectation. | |
| 67 NET_ERROR(UPLOAD_FILE_CHANGED, -14) | |
| 68 | |
| 69 // The socket is not connected. | |
| 70 NET_ERROR(SOCKET_NOT_CONNECTED, -15) | |
| 71 | |
| 72 // The file already exists. | |
| 73 NET_ERROR(FILE_EXISTS, -16) | |
| 74 | |
| 75 // The path or file name is too long. | |
| 76 NET_ERROR(FILE_PATH_TOO_LONG, -17) | |
| 77 | |
| 78 // Not enough room left on the disk. | |
| 79 NET_ERROR(FILE_NO_SPACE, -18) | |
| 80 | |
| 81 // The file has a virus. | |
| 82 NET_ERROR(FILE_VIRUS_INFECTED, -19) | |
| 83 | |
| 84 // The client chose to block the request. | |
| 85 NET_ERROR(BLOCKED_BY_CLIENT, -20) | |
| 86 | |
| 87 // The network changed. | |
| 88 NET_ERROR(NETWORK_CHANGED, -21) | |
| 89 | |
| 90 // The request was blocked by the URL blacklist configured by the domain | |
| 91 // administrator. | |
| 92 NET_ERROR(BLOCKED_BY_ADMINISTRATOR, -22) | |
| 93 | |
| 94 // The socket is already connected. | |
| 95 NET_ERROR(SOCKET_IS_CONNECTED, -23) | |
| 96 | |
| 97 // The request was blocked because the forced reenrollment check is still | |
| 98 // pending. This error can only occur on ChromeOS. | |
| 99 // The error can be emitted by code in chrome/browser/policy/policy_helpers.cc. | |
| 100 NET_ERROR(BLOCKED_ENROLLMENT_CHECK_PENDING, -24) | |
| 101 | |
| 102 // The upload failed because the upload stream needed to be re-read, due to a | |
| 103 // retry or a redirect, but the upload stream doesn't support that operation. | |
| 104 NET_ERROR(UPLOAD_STREAM_REWIND_NOT_SUPPORTED, -25) | |
| 105 | |
| 106 // A connection was closed (corresponding to a TCP FIN). | |
| 107 NET_ERROR(CONNECTION_CLOSED, -100) | |
| 108 | |
| 109 // A connection was reset (corresponding to a TCP RST). | |
| 110 NET_ERROR(CONNECTION_RESET, -101) | |
| 111 | |
| 112 // A connection attempt was refused. | |
| 113 NET_ERROR(CONNECTION_REFUSED, -102) | |
| 114 | |
| 115 // A connection timed out as a result of not receiving an ACK for data sent. | |
| 116 // This can include a FIN packet that did not get ACK'd. | |
| 117 NET_ERROR(CONNECTION_ABORTED, -103) | |
| 118 | |
| 119 // A connection attempt failed. | |
| 120 NET_ERROR(CONNECTION_FAILED, -104) | |
| 121 | |
| 122 // The host name could not be resolved. | |
| 123 NET_ERROR(NAME_NOT_RESOLVED, -105) | |
| 124 | |
| 125 // The Internet connection has been lost. | |
| 126 NET_ERROR(INTERNET_DISCONNECTED, -106) | |
| 127 | |
| 128 // An SSL protocol error occurred. | |
| 129 NET_ERROR(SSL_PROTOCOL_ERROR, -107) | |
| 130 | |
| 131 // The IP address or port number is invalid (e.g., cannot connect to the IP | |
| 132 // address 0 or the port 0). | |
| 133 NET_ERROR(ADDRESS_INVALID, -108) | |
| 134 | |
| 135 // The IP address is unreachable. This usually means that there is no route to | |
| 136 // the specified host or network. | |
| 137 NET_ERROR(ADDRESS_UNREACHABLE, -109) | |
| 138 | |
| 139 // The server requested a client certificate for SSL client authentication. | |
| 140 NET_ERROR(SSL_CLIENT_AUTH_CERT_NEEDED, -110) | |
| 141 | |
| 142 // A tunnel connection through the proxy could not be established. | |
| 143 NET_ERROR(TUNNEL_CONNECTION_FAILED, -111) | |
| 144 | |
| 145 // No SSL protocol versions are enabled. | |
| 146 NET_ERROR(NO_SSL_VERSIONS_ENABLED, -112) | |
| 147 | |
| 148 // The client and server don't support a common SSL protocol version or | |
| 149 // cipher suite. | |
| 150 NET_ERROR(SSL_VERSION_OR_CIPHER_MISMATCH, -113) | |
| 151 | |
| 152 // The server requested a renegotiation (rehandshake). | |
| 153 NET_ERROR(SSL_RENEGOTIATION_REQUESTED, -114) | |
| 154 | |
| 155 // The proxy requested authentication (for tunnel establishment) with an | |
| 156 // unsupported method. | |
| 157 NET_ERROR(PROXY_AUTH_UNSUPPORTED, -115) | |
| 158 | |
| 159 // During SSL renegotiation (rehandshake), the server sent a certificate with | |
| 160 // an error. | |
| 161 // | |
| 162 // Note: this error is not in the -2xx range so that it won't be handled as a | |
| 163 // certificate error. | |
| 164 NET_ERROR(CERT_ERROR_IN_SSL_RENEGOTIATION, -116) | |
| 165 | |
| 166 // The SSL handshake failed because of a bad or missing client certificate. | |
| 167 NET_ERROR(BAD_SSL_CLIENT_AUTH_CERT, -117) | |
| 168 | |
| 169 // A connection attempt timed out. | |
| 170 NET_ERROR(CONNECTION_TIMED_OUT, -118) | |
| 171 | |
| 172 // There are too many pending DNS resolves, so a request in the queue was | |
| 173 // aborted. | |
| 174 NET_ERROR(HOST_RESOLVER_QUEUE_TOO_LARGE, -119) | |
| 175 | |
| 176 // Failed establishing a connection to the SOCKS proxy server for a target host. | |
| 177 NET_ERROR(SOCKS_CONNECTION_FAILED, -120) | |
| 178 | |
| 179 // The SOCKS proxy server failed establishing connection to the target host | |
| 180 // because that host is unreachable. | |
| 181 NET_ERROR(SOCKS_CONNECTION_HOST_UNREACHABLE, -121) | |
| 182 | |
| 183 // The request to negotiate an alternate protocol failed. | |
| 184 NET_ERROR(NPN_NEGOTIATION_FAILED, -122) | |
| 185 | |
| 186 // The peer sent an SSL no_renegotiation alert message. | |
| 187 NET_ERROR(SSL_NO_RENEGOTIATION, -123) | |
| 188 | |
| 189 // Winsock sometimes reports more data written than passed. This is probably | |
| 190 // due to a broken LSP. | |
| 191 NET_ERROR(WINSOCK_UNEXPECTED_WRITTEN_BYTES, -124) | |
| 192 | |
| 193 // An SSL peer sent us a fatal decompression_failure alert. This typically | |
| 194 // occurs when a peer selects DEFLATE compression in the mistaken belief that | |
| 195 // it supports it. | |
| 196 NET_ERROR(SSL_DECOMPRESSION_FAILURE_ALERT, -125) | |
| 197 | |
| 198 // An SSL peer sent us a fatal bad_record_mac alert. This has been observed | |
| 199 // from servers with buggy DEFLATE support. | |
| 200 NET_ERROR(SSL_BAD_RECORD_MAC_ALERT, -126) | |
| 201 | |
| 202 // The proxy requested authentication (for tunnel establishment). | |
| 203 NET_ERROR(PROXY_AUTH_REQUESTED, -127) | |
| 204 | |
| 205 // A known TLS strict server didn't offer the renegotiation extension. | |
| 206 NET_ERROR(SSL_UNSAFE_NEGOTIATION, -128) | |
| 207 | |
| 208 // The SSL server attempted to use a weak ephemeral Diffie-Hellman key. | |
| 209 NET_ERROR(SSL_WEAK_SERVER_EPHEMERAL_DH_KEY, -129) | |
| 210 | |
| 211 // Could not create a connection to the proxy server. An error occurred | |
| 212 // either in resolving its name, or in connecting a socket to it. | |
| 213 // Note that this does NOT include failures during the actual "CONNECT" method | |
| 214 // of an HTTP proxy. | |
| 215 NET_ERROR(PROXY_CONNECTION_FAILED, -130) | |
| 216 | |
| 217 // A mandatory proxy configuration could not be used. Currently this means | |
| 218 // that a mandatory PAC script could not be fetched, parsed or executed. | |
| 219 NET_ERROR(MANDATORY_PROXY_CONFIGURATION_FAILED, -131) | |
| 220 | |
| 221 // -132 was formerly ERR_ESET_ANTI_VIRUS_SSL_INTERCEPTION | |
| 222 | |
| 223 // We've hit the max socket limit for the socket pool while preconnecting. We | |
| 224 // don't bother trying to preconnect more sockets. | |
| 225 NET_ERROR(PRECONNECT_MAX_SOCKET_LIMIT, -133) | |
| 226 | |
| 227 // The permission to use the SSL client certificate's private key was denied. | |
| 228 NET_ERROR(SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED, -134) | |
| 229 | |
| 230 // The SSL client certificate has no private key. | |
| 231 NET_ERROR(SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY, -135) | |
| 232 | |
| 233 // The certificate presented by the HTTPS Proxy was invalid. | |
| 234 NET_ERROR(PROXY_CERTIFICATE_INVALID, -136) | |
| 235 | |
| 236 // An error occurred when trying to do a name resolution (DNS). | |
| 237 NET_ERROR(NAME_RESOLUTION_FAILED, -137) | |
| 238 | |
| 239 // Permission to access the network was denied. This is used to distinguish | |
| 240 // errors that were most likely caused by a firewall from other access denied | |
| 241 // errors. See also ERR_ACCESS_DENIED. | |
| 242 NET_ERROR(NETWORK_ACCESS_DENIED, -138) | |
| 243 | |
| 244 // The request throttler module cancelled this request to avoid DDOS. | |
| 245 NET_ERROR(TEMPORARILY_THROTTLED, -139) | |
| 246 | |
| 247 // A request to create an SSL tunnel connection through the HTTPS proxy | |
| 248 // received a non-200 (OK) and non-407 (Proxy Auth) response. The response | |
| 249 // body might include a description of why the request failed. | |
| 250 NET_ERROR(HTTPS_PROXY_TUNNEL_RESPONSE, -140) | |
| 251 | |
| 252 // We were unable to sign the CertificateVerify data of an SSL client auth | |
| 253 // handshake with the client certificate's private key. | |
| 254 // | |
| 255 // Possible causes for this include the user implicitly or explicitly | |
| 256 // denying access to the private key, the private key may not be valid for | |
| 257 // signing, the key may be relying on a cached handle which is no longer | |
| 258 // valid, or the CSP won't allow arbitrary data to be signed. | |
| 259 NET_ERROR(SSL_CLIENT_AUTH_SIGNATURE_FAILED, -141) | |
| 260 | |
| 261 // The message was too large for the transport. (for example a UDP message | |
| 262 // which exceeds size threshold). | |
| 263 NET_ERROR(MSG_TOO_BIG, -142) | |
| 264 | |
| 265 // A SPDY session already exists, and should be used instead of this connection. | |
| 266 NET_ERROR(SPDY_SESSION_ALREADY_EXISTS, -143) | |
| 267 | |
| 268 // Error -144 was removed (LIMIT_VIOLATION). | |
| 269 | |
| 270 // Websocket protocol error. Indicates that we are terminating the connection | |
| 271 // due to a malformed frame or other protocol violation. | |
| 272 NET_ERROR(WS_PROTOCOL_ERROR, -145) | |
| 273 | |
| 274 // Error -146 was removed (PROTOCOL_SWITCHED) | |
| 275 | |
| 276 // Returned when attempting to bind an address that is already in use. | |
| 277 NET_ERROR(ADDRESS_IN_USE, -147) | |
| 278 | |
| 279 // An operation failed because the SSL handshake has not completed. | |
| 280 NET_ERROR(SSL_HANDSHAKE_NOT_COMPLETED, -148) | |
| 281 | |
| 282 // SSL peer's public key is invalid. | |
| 283 NET_ERROR(SSL_BAD_PEER_PUBLIC_KEY, -149) | |
| 284 | |
| 285 // The certificate didn't match the built-in public key pins for the host name. | |
| 286 // The pins are set in net/http/transport_security_state.cc and require that | |
| 287 // one of a set of public keys exist on the path from the leaf to the root. | |
| 288 NET_ERROR(SSL_PINNED_KEY_NOT_IN_CERT_CHAIN, -150) | |
| 289 | |
| 290 // Server request for client certificate did not contain any types we support. | |
| 291 NET_ERROR(CLIENT_AUTH_CERT_TYPE_UNSUPPORTED, -151) | |
| 292 | |
| 293 // Server requested one type of cert, then requested a different type while the | |
| 294 // first was still being generated. | |
| 295 NET_ERROR(ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH, -152) | |
| 296 | |
| 297 // An SSL peer sent us a fatal decrypt_error alert. This typically occurs when | |
| 298 // a peer could not correctly verify a signature (in CertificateVerify or | |
| 299 // ServerKeyExchange) or validate a Finished message. | |
| 300 NET_ERROR(SSL_DECRYPT_ERROR_ALERT, -153) | |
| 301 | |
| 302 // There are too many pending WebSocketJob instances, so the new job was not | |
| 303 // pushed to the queue. | |
| 304 NET_ERROR(WS_THROTTLE_QUEUE_TOO_LARGE, -154) | |
| 305 | |
| 306 // Error -155 was removed (TOO_MANY_SOCKET_STREAMS) | |
| 307 | |
| 308 // The SSL server certificate changed in a renegotiation. | |
| 309 NET_ERROR(SSL_SERVER_CERT_CHANGED, -156) | |
| 310 | |
| 311 // The SSL server indicated that an unnecessary TLS version fallback was | |
| 312 // performed. | |
| 313 NET_ERROR(SSL_INAPPROPRIATE_FALLBACK, -157) | |
| 314 | |
| 315 // Certificate Transparency: All Signed Certificate Timestamps failed to verify. | |
| 316 NET_ERROR(CT_NO_SCTS_VERIFIED_OK, -158) | |
| 317 | |
| 318 // The SSL server sent us a fatal unrecognized_name alert. | |
| 319 NET_ERROR(SSL_UNRECOGNIZED_NAME_ALERT, -159) | |
| 320 | |
| 321 // Failed to set the socket's receive buffer size as requested. | |
| 322 NET_ERROR(SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR, -160) | |
| 323 | |
| 324 // Failed to set the socket's send buffer size as requested. | |
| 325 NET_ERROR(SOCKET_SET_SEND_BUFFER_SIZE_ERROR, -161) | |
| 326 | |
| 327 // Failed to set the socket's receive buffer size as requested, despite success | |
| 328 // return code from setsockopt. | |
| 329 NET_ERROR(SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE, -162) | |
| 330 | |
| 331 // Failed to set the socket's send buffer size as requested, despite success | |
| 332 // return code from setsockopt. | |
| 333 NET_ERROR(SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE, -163) | |
| 334 | |
| 335 // Failed to import a client certificate from the platform store into the SSL | |
| 336 // library. | |
| 337 NET_ERROR(SSL_CLIENT_AUTH_CERT_BAD_FORMAT, -164) | |
| 338 | |
| 339 // The SSL server requires falling back to a version older than the configured | |
| 340 // minimum fallback version, and thus fallback failed. | |
| 341 NET_ERROR(SSL_FALLBACK_BEYOND_MINIMUM_VERSION, -165) | |
| 342 | |
| 343 // Certificate error codes | |
| 344 // | |
| 345 // The values of certificate error codes must be consecutive. | |
| 346 | |
| 347 // The server responded with a certificate whose common name did not match | |
| 348 // the host name. This could mean: | |
| 349 // | |
| 350 // 1. An attacker has redirected our traffic to his server and is | |
| 351 // presenting a certificate for which he knows the private key. | |
| 352 // | |
| 353 // 2. The server is misconfigured and responding with the wrong cert. | |
| 354 // | |
| 355 // 3. The user is on a wireless network and is being redirected to the | |
| 356 // network's login page. | |
| 357 // | |
| 358 // 4. The OS has used a DNS search suffix and the server doesn't have | |
| 359 // a certificate for the abbreviated name in the address bar. | |
| 360 // | |
| 361 NET_ERROR(CERT_COMMON_NAME_INVALID, -200) | |
| 362 | |
| 363 // The server responded with a certificate that, by our clock, appears to | |
| 364 // either not yet be valid or to have expired. This could mean: | |
| 365 // | |
| 366 // 1. An attacker is presenting an old certificate for which he has | |
| 367 // managed to obtain the private key. | |
| 368 // | |
| 369 // 2. The server is misconfigured and is not presenting a valid cert. | |
| 370 // | |
| 371 // 3. Our clock is wrong. | |
| 372 // | |
| 373 NET_ERROR(CERT_DATE_INVALID, -201) | |
| 374 | |
| 375 // The server responded with a certificate that is signed by an authority | |
| 376 // we don't trust. The could mean: | |
| 377 // | |
| 378 // 1. An attacker has substituted the real certificate for a cert that | |
| 379 // contains his public key and is signed by his cousin. | |
| 380 // | |
| 381 // 2. The server operator has a legitimate certificate from a CA we don't | |
| 382 // know about, but should trust. | |
| 383 // | |
| 384 // 3. The server is presenting a self-signed certificate, providing no | |
| 385 // defense against active attackers (but foiling passive attackers). | |
| 386 // | |
| 387 NET_ERROR(CERT_AUTHORITY_INVALID, -202) | |
| 388 | |
| 389 // The server responded with a certificate that contains errors. | |
| 390 // This error is not recoverable. | |
| 391 // | |
| 392 // MSDN describes this error as follows: | |
| 393 // "The SSL certificate contains errors." | |
| 394 // NOTE: It's unclear how this differs from ERR_CERT_INVALID. For consistency, | |
| 395 // use that code instead of this one from now on. | |
| 396 // | |
| 397 NET_ERROR(CERT_CONTAINS_ERRORS, -203) | |
| 398 | |
| 399 // The certificate has no mechanism for determining if it is revoked. In | |
| 400 // effect, this certificate cannot be revoked. | |
| 401 NET_ERROR(CERT_NO_REVOCATION_MECHANISM, -204) | |
| 402 | |
| 403 // Revocation information for the security certificate for this site is not | |
| 404 // available. This could mean: | |
| 405 // | |
| 406 // 1. An attacker has compromised the private key in the certificate and is | |
| 407 // blocking our attempt to find out that the cert was revoked. | |
| 408 // | |
| 409 // 2. The certificate is unrevoked, but the revocation server is busy or | |
| 410 // unavailable. | |
| 411 // | |
| 412 NET_ERROR(CERT_UNABLE_TO_CHECK_REVOCATION, -205) | |
| 413 | |
| 414 // The server responded with a certificate has been revoked. | |
| 415 // We have the capability to ignore this error, but it is probably not the | |
| 416 // thing to do. | |
| 417 NET_ERROR(CERT_REVOKED, -206) | |
| 418 | |
| 419 // The server responded with a certificate that is invalid. | |
| 420 // This error is not recoverable. | |
| 421 // | |
| 422 // MSDN describes this error as follows: | |
| 423 // "The SSL certificate is invalid." | |
| 424 // | |
| 425 NET_ERROR(CERT_INVALID, -207) | |
| 426 | |
| 427 // The server responded with a certificate that is signed using a weak | |
| 428 // signature algorithm. | |
| 429 NET_ERROR(CERT_WEAK_SIGNATURE_ALGORITHM, -208) | |
| 430 | |
| 431 // -209 is availible: was CERT_NOT_IN_DNS. | |
| 432 | |
| 433 // The host name specified in the certificate is not unique. | |
| 434 NET_ERROR(CERT_NON_UNIQUE_NAME, -210) | |
| 435 | |
| 436 // The server responded with a certificate that contains a weak key (e.g. | |
| 437 // a too-small RSA key). | |
| 438 NET_ERROR(CERT_WEAK_KEY, -211) | |
| 439 | |
| 440 // The certificate claimed DNS names that are in violation of name constraints. | |
| 441 NET_ERROR(CERT_NAME_CONSTRAINT_VIOLATION, -212) | |
| 442 | |
| 443 // The certificate's validity period is too long. | |
| 444 NET_ERROR(CERT_VALIDITY_TOO_LONG, -213) | |
| 445 | |
| 446 // Add new certificate error codes here. | |
| 447 // | |
| 448 // Update the value of CERT_END whenever you add a new certificate error | |
| 449 // code. | |
| 450 | |
| 451 // The value immediately past the last certificate error code. | |
| 452 NET_ERROR(CERT_END, -214) | |
| 453 | |
| 454 // The URL is invalid. | |
| 455 NET_ERROR(INVALID_URL, -300) | |
| 456 | |
| 457 // The scheme of the URL is disallowed. | |
| 458 NET_ERROR(DISALLOWED_URL_SCHEME, -301) | |
| 459 | |
| 460 // The scheme of the URL is unknown. | |
| 461 NET_ERROR(UNKNOWN_URL_SCHEME, -302) | |
| 462 | |
| 463 // Attempting to load an URL resulted in too many redirects. | |
| 464 NET_ERROR(TOO_MANY_REDIRECTS, -310) | |
| 465 | |
| 466 // Attempting to load an URL resulted in an unsafe redirect (e.g., a redirect | |
| 467 // to file:// is considered unsafe). | |
| 468 NET_ERROR(UNSAFE_REDIRECT, -311) | |
| 469 | |
| 470 // Attempting to load an URL with an unsafe port number. These are port | |
| 471 // numbers that correspond to services, which are not robust to spurious input | |
| 472 // that may be constructed as a result of an allowed web construct (e.g., HTTP | |
| 473 // looks a lot like SMTP, so form submission to port 25 is denied). | |
| 474 NET_ERROR(UNSAFE_PORT, -312) | |
| 475 | |
| 476 // The server's response was invalid. | |
| 477 NET_ERROR(INVALID_RESPONSE, -320) | |
| 478 | |
| 479 // Error in chunked transfer encoding. | |
| 480 NET_ERROR(INVALID_CHUNKED_ENCODING, -321) | |
| 481 | |
| 482 // The server did not support the request method. | |
| 483 NET_ERROR(METHOD_NOT_SUPPORTED, -322) | |
| 484 | |
| 485 // The response was 407 (Proxy Authentication Required), yet we did not send | |
| 486 // the request to a proxy. | |
| 487 NET_ERROR(UNEXPECTED_PROXY_AUTH, -323) | |
| 488 | |
| 489 // The server closed the connection without sending any data. | |
| 490 NET_ERROR(EMPTY_RESPONSE, -324) | |
| 491 | |
| 492 // The headers section of the response is too large. | |
| 493 NET_ERROR(RESPONSE_HEADERS_TOO_BIG, -325) | |
| 494 | |
| 495 // The PAC requested by HTTP did not have a valid status code (non-200). | |
| 496 NET_ERROR(PAC_STATUS_NOT_OK, -326) | |
| 497 | |
| 498 // The evaluation of the PAC script failed. | |
| 499 NET_ERROR(PAC_SCRIPT_FAILED, -327) | |
| 500 | |
| 501 // The response was 416 (Requested range not satisfiable) and the server cannot | |
| 502 // satisfy the range requested. | |
| 503 NET_ERROR(REQUEST_RANGE_NOT_SATISFIABLE, -328) | |
| 504 | |
| 505 // The identity used for authentication is invalid. | |
| 506 NET_ERROR(MALFORMED_IDENTITY, -329) | |
| 507 | |
| 508 // Content decoding of the response body failed. | |
| 509 NET_ERROR(CONTENT_DECODING_FAILED, -330) | |
| 510 | |
| 511 // An operation could not be completed because all network IO | |
| 512 // is suspended. | |
| 513 NET_ERROR(NETWORK_IO_SUSPENDED, -331) | |
| 514 | |
| 515 // FLIP data received without receiving a SYN_REPLY on the stream. | |
| 516 NET_ERROR(SYN_REPLY_NOT_RECEIVED, -332) | |
| 517 | |
| 518 // Converting the response to target encoding failed. | |
| 519 NET_ERROR(ENCODING_CONVERSION_FAILED, -333) | |
| 520 | |
| 521 // The server sent an FTP directory listing in a format we do not understand. | |
| 522 NET_ERROR(UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT, -334) | |
| 523 | |
| 524 // Attempted use of an unknown SPDY stream id. | |
| 525 NET_ERROR(INVALID_SPDY_STREAM, -335) | |
| 526 | |
| 527 // There are no supported proxies in the provided list. | |
| 528 NET_ERROR(NO_SUPPORTED_PROXIES, -336) | |
| 529 | |
| 530 // There is a SPDY protocol error. | |
| 531 NET_ERROR(SPDY_PROTOCOL_ERROR, -337) | |
| 532 | |
| 533 // Credentials could not be established during HTTP Authentication. | |
| 534 NET_ERROR(INVALID_AUTH_CREDENTIALS, -338) | |
| 535 | |
| 536 // An HTTP Authentication scheme was tried which is not supported on this | |
| 537 // machine. | |
| 538 NET_ERROR(UNSUPPORTED_AUTH_SCHEME, -339) | |
| 539 | |
| 540 // Detecting the encoding of the response failed. | |
| 541 NET_ERROR(ENCODING_DETECTION_FAILED, -340) | |
| 542 | |
| 543 // (GSSAPI) No Kerberos credentials were available during HTTP Authentication. | |
| 544 NET_ERROR(MISSING_AUTH_CREDENTIALS, -341) | |
| 545 | |
| 546 // An unexpected, but documented, SSPI or GSSAPI status code was returned. | |
| 547 NET_ERROR(UNEXPECTED_SECURITY_LIBRARY_STATUS, -342) | |
| 548 | |
| 549 // The environment was not set up correctly for authentication (for | |
| 550 // example, no KDC could be found or the principal is unknown. | |
| 551 NET_ERROR(MISCONFIGURED_AUTH_ENVIRONMENT, -343) | |
| 552 | |
| 553 // An undocumented SSPI or GSSAPI status code was returned. | |
| 554 NET_ERROR(UNDOCUMENTED_SECURITY_LIBRARY_STATUS, -344) | |
| 555 | |
| 556 // The HTTP response was too big to drain. | |
| 557 NET_ERROR(RESPONSE_BODY_TOO_BIG_TO_DRAIN, -345) | |
| 558 | |
| 559 // The HTTP response contained multiple distinct Content-Length headers. | |
| 560 NET_ERROR(RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH, -346) | |
| 561 | |
| 562 // SPDY Headers have been received, but not all of them - status or version | |
| 563 // headers are missing, so we're expecting additional frames to complete them. | |
| 564 NET_ERROR(INCOMPLETE_SPDY_HEADERS, -347) | |
| 565 | |
| 566 // No PAC URL configuration could be retrieved from DHCP. This can indicate | |
| 567 // either a failure to retrieve the DHCP configuration, or that there was no | |
| 568 // PAC URL configured in DHCP. | |
| 569 NET_ERROR(PAC_NOT_IN_DHCP, -348) | |
| 570 | |
| 571 // The HTTP response contained multiple Content-Disposition headers. | |
| 572 NET_ERROR(RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION, -349) | |
| 573 | |
| 574 // The HTTP response contained multiple Location headers. | |
| 575 NET_ERROR(RESPONSE_HEADERS_MULTIPLE_LOCATION, -350) | |
| 576 | |
| 577 // SPDY server refused the stream. Client should retry. This should never be a | |
| 578 // user-visible error. | |
| 579 NET_ERROR(SPDY_SERVER_REFUSED_STREAM, -351) | |
| 580 | |
| 581 // SPDY server didn't respond to the PING message. | |
| 582 NET_ERROR(SPDY_PING_FAILED, -352) | |
| 583 | |
| 584 // Obsolete. Kept here to avoid reuse, as the old error can still appear on | |
| 585 // histograms. | |
| 586 // NET_ERROR(PIPELINE_EVICTION, -353) | |
| 587 | |
| 588 // The HTTP response body transferred fewer bytes than were advertised by the | |
| 589 // Content-Length header when the connection is closed. | |
| 590 NET_ERROR(CONTENT_LENGTH_MISMATCH, -354) | |
| 591 | |
| 592 // The HTTP response body is transferred with Chunked-Encoding, but the | |
| 593 // terminating zero-length chunk was never sent when the connection is closed. | |
| 594 NET_ERROR(INCOMPLETE_CHUNKED_ENCODING, -355) | |
| 595 | |
| 596 // There is a QUIC protocol error. | |
| 597 NET_ERROR(QUIC_PROTOCOL_ERROR, -356) | |
| 598 | |
| 599 // The HTTP headers were truncated by an EOF. | |
| 600 NET_ERROR(RESPONSE_HEADERS_TRUNCATED, -357) | |
| 601 | |
| 602 // The QUIC crytpo handshake failed. This means that the server was unable | |
| 603 // to read any requests sent, so they may be resent. | |
| 604 NET_ERROR(QUIC_HANDSHAKE_FAILED, -358) | |
| 605 | |
| 606 // An https resource was requested over an insecure QUIC connection. | |
| 607 NET_ERROR(REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC, -359) | |
| 608 | |
| 609 // Transport security is inadequate for the SPDY version. | |
| 610 NET_ERROR(SPDY_INADEQUATE_TRANSPORT_SECURITY, -360) | |
| 611 | |
| 612 // The peer violated SPDY flow control. | |
| 613 NET_ERROR(SPDY_FLOW_CONTROL_ERROR, -361) | |
| 614 | |
| 615 // The peer sent an improperly sized SPDY frame. | |
| 616 NET_ERROR(SPDY_FRAME_SIZE_ERROR, -362) | |
| 617 | |
| 618 // Decoding or encoding of compressed SPDY headers failed. | |
| 619 NET_ERROR(SPDY_COMPRESSION_ERROR, -363) | |
| 620 | |
| 621 // Proxy Auth Requested without a valid Client Socket Handle. | |
| 622 NET_ERROR(PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION, -364) | |
| 623 | |
| 624 // HTTP_1_1_REQUIRED error code received on HTTP/2 session. | |
| 625 NET_ERROR(HTTP_1_1_REQUIRED, -365) | |
| 626 | |
| 627 // HTTP_1_1_REQUIRED error code received on HTTP/2 session to proxy. | |
| 628 NET_ERROR(PROXY_HTTP_1_1_REQUIRED, -366) | |
| 629 | |
| 630 // The cache does not have the requested entry. | |
| 631 NET_ERROR(CACHE_MISS, -400) | |
| 632 | |
| 633 // Unable to read from the disk cache. | |
| 634 NET_ERROR(CACHE_READ_FAILURE, -401) | |
| 635 | |
| 636 // Unable to write to the disk cache. | |
| 637 NET_ERROR(CACHE_WRITE_FAILURE, -402) | |
| 638 | |
| 639 // The operation is not supported for this entry. | |
| 640 NET_ERROR(CACHE_OPERATION_NOT_SUPPORTED, -403) | |
| 641 | |
| 642 // The disk cache is unable to open this entry. | |
| 643 NET_ERROR(CACHE_OPEN_FAILURE, -404) | |
| 644 | |
| 645 // The disk cache is unable to create this entry. | |
| 646 NET_ERROR(CACHE_CREATE_FAILURE, -405) | |
| 647 | |
| 648 // Multiple transactions are racing to create disk cache entries. This is an | |
| 649 // internal error returned from the HttpCache to the HttpCacheTransaction that | |
| 650 // tells the transaction to restart the entry-creation logic because the state | |
| 651 // of the cache has changed. | |
| 652 NET_ERROR(CACHE_RACE, -406) | |
| 653 | |
| 654 // The cache was unable to read a checksum record on an entry. This can be | |
| 655 // returned from attempts to read from the cache. It is an internal error, | |
| 656 // returned by the SimpleCache backend, but not by any URLRequest methods | |
| 657 // or members. | |
| 658 NET_ERROR(CACHE_CHECKSUM_READ_FAILURE, -407) | |
| 659 | |
| 660 // The cache found an entry with an invalid checksum. This can be returned from | |
| 661 // attempts to read from the cache. It is an internal error, returned by the | |
| 662 // SimpleCache backend, but not by any URLRequest methods or members. | |
| 663 NET_ERROR(CACHE_CHECKSUM_MISMATCH, -408) | |
| 664 | |
| 665 // Internal error code for the HTTP cache. The cache lock timeout has fired. | |
| 666 NET_ERROR(CACHE_LOCK_TIMEOUT, -409) | |
| 667 | |
| 668 // The server's response was insecure (e.g. there was a cert error). | |
| 669 NET_ERROR(INSECURE_RESPONSE, -501) | |
| 670 | |
| 671 // The server responded to a <keygen> with a generated client cert that we | |
| 672 // don't have the matching private key for. | |
| 673 NET_ERROR(NO_PRIVATE_KEY_FOR_CERT, -502) | |
| 674 | |
| 675 // An error adding to the OS certificate database (e.g. OS X Keychain). | |
| 676 NET_ERROR(ADD_USER_CERT_FAILED, -503) | |
| 677 | |
| 678 // *** Code -600 is reserved (was FTP_PASV_COMMAND_FAILED). *** | |
| 679 | |
| 680 // A generic error for failed FTP control connection command. | |
| 681 // If possible, please use or add a more specific error code. | |
| 682 NET_ERROR(FTP_FAILED, -601) | |
| 683 | |
| 684 // The server cannot fulfill the request at this point. This is a temporary | |
| 685 // error. | |
| 686 // FTP response code 421. | |
| 687 NET_ERROR(FTP_SERVICE_UNAVAILABLE, -602) | |
| 688 | |
| 689 // The server has aborted the transfer. | |
| 690 // FTP response code 426. | |
| 691 NET_ERROR(FTP_TRANSFER_ABORTED, -603) | |
| 692 | |
| 693 // The file is busy, or some other temporary error condition on opening | |
| 694 // the file. | |
| 695 // FTP response code 450. | |
| 696 NET_ERROR(FTP_FILE_BUSY, -604) | |
| 697 | |
| 698 // Server rejected our command because of syntax errors. | |
| 699 // FTP response codes 500, 501. | |
| 700 NET_ERROR(FTP_SYNTAX_ERROR, -605) | |
| 701 | |
| 702 // Server does not support the command we issued. | |
| 703 // FTP response codes 502, 504. | |
| 704 NET_ERROR(FTP_COMMAND_NOT_SUPPORTED, -606) | |
| 705 | |
| 706 // Server rejected our command because we didn't issue the commands in right | |
| 707 // order. | |
| 708 // FTP response code 503. | |
| 709 NET_ERROR(FTP_BAD_COMMAND_SEQUENCE, -607) | |
| 710 | |
| 711 // PKCS #12 import failed due to incorrect password. | |
| 712 NET_ERROR(PKCS12_IMPORT_BAD_PASSWORD, -701) | |
| 713 | |
| 714 // PKCS #12 import failed due to other error. | |
| 715 NET_ERROR(PKCS12_IMPORT_FAILED, -702) | |
| 716 | |
| 717 // CA import failed - not a CA cert. | |
| 718 NET_ERROR(IMPORT_CA_CERT_NOT_CA, -703) | |
| 719 | |
| 720 // Import failed - certificate already exists in database. | |
| 721 // Note it's a little weird this is an error but reimporting a PKCS12 is ok | |
| 722 // (no-op). That's how Mozilla does it, though. | |
| 723 NET_ERROR(IMPORT_CERT_ALREADY_EXISTS, -704) | |
| 724 | |
| 725 // CA import failed due to some other error. | |
| 726 NET_ERROR(IMPORT_CA_CERT_FAILED, -705) | |
| 727 | |
| 728 // Server certificate import failed due to some internal error. | |
| 729 NET_ERROR(IMPORT_SERVER_CERT_FAILED, -706) | |
| 730 | |
| 731 // PKCS #12 import failed due to invalid MAC. | |
| 732 NET_ERROR(PKCS12_IMPORT_INVALID_MAC, -707) | |
| 733 | |
| 734 // PKCS #12 import failed due to invalid/corrupt file. | |
| 735 NET_ERROR(PKCS12_IMPORT_INVALID_FILE, -708) | |
| 736 | |
| 737 // PKCS #12 import failed due to unsupported features. | |
| 738 NET_ERROR(PKCS12_IMPORT_UNSUPPORTED, -709) | |
| 739 | |
| 740 // Key generation failed. | |
| 741 NET_ERROR(KEY_GENERATION_FAILED, -710) | |
| 742 | |
| 743 // Server-bound certificate generation failed. | |
| 744 NET_ERROR(ORIGIN_BOUND_CERT_GENERATION_FAILED, -711) | |
| 745 | |
| 746 // Failure to export private key. | |
| 747 NET_ERROR(PRIVATE_KEY_EXPORT_FAILED, -712) | |
| 748 | |
| 749 // Self-signed certificate generation failed. | |
| 750 NET_ERROR(SELF_SIGNED_CERT_GENERATION_FAILED, -713) | |
| 751 | |
| 752 // The certificate database changed in some way. | |
| 753 NET_ERROR(CERT_DATABASE_CHANGED, -714) | |
| 754 | |
| 755 // Failure to import Channel ID. | |
| 756 NET_ERROR(CHANNEL_ID_IMPORT_FAILED, -715) | |
| 757 | |
| 758 // DNS error codes. | |
| 759 | |
| 760 // DNS resolver received a malformed response. | |
| 761 NET_ERROR(DNS_MALFORMED_RESPONSE, -800) | |
| 762 | |
| 763 // DNS server requires TCP | |
| 764 NET_ERROR(DNS_SERVER_REQUIRES_TCP, -801) | |
| 765 | |
| 766 // DNS server failed. This error is returned for all of the following | |
| 767 // error conditions: | |
| 768 // 1 - Format error - The name server was unable to interpret the query. | |
| 769 // 2 - Server failure - The name server was unable to process this query | |
| 770 // due to a problem with the name server. | |
| 771 // 4 - Not Implemented - The name server does not support the requested | |
| 772 // kind of query. | |
| 773 // 5 - Refused - The name server refuses to perform the specified | |
| 774 // operation for policy reasons. | |
| 775 NET_ERROR(DNS_SERVER_FAILED, -802) | |
| 776 | |
| 777 // DNS transaction timed out. | |
| 778 NET_ERROR(DNS_TIMED_OUT, -803) | |
| 779 | |
| 780 // The entry was not found in cache, for cache-only lookups. | |
| 781 NET_ERROR(DNS_CACHE_MISS, -804) | |
| 782 | |
| 783 // Suffix search list rules prevent resolution of the given host name. | |
| 784 NET_ERROR(DNS_SEARCH_EMPTY, -805) | |
| 785 | |
| 786 // Failed to sort addresses according to RFC3484. | |
| 787 NET_ERROR(DNS_SORT_ERROR, -806) | |
| OLD | NEW |