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 |