1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/net_errors.h"
#include <string>
#include "base/check_op.h"
#include "base/files/file.h"
#include "base/logging.h"
#include "base/notreached.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_error_codes.h"
namespace net {
// Validate all error values in net_error_list.h are negative.
#define NET_ERROR(label, value) \
static_assert(value < 0, "ERR_" #label " should be negative");
#include "net/base/net_error_list.h"
#undef NET_ERROR
std::string ErrorToString(int error) {
return "net::" + ErrorToShortString(error);
}
std::string ExtendedErrorToString(int error, int extended_error_code) {
if (error == ERR_QUIC_PROTOCOL_ERROR && extended_error_code != 0) {
return std::string("net::ERR_QUIC_PROTOCOL_ERROR.") +
QuicErrorCodeToString(
static_cast<quic::QuicErrorCode>(extended_error_code));
}
return ErrorToString(error);
}
std::string ErrorToShortString(int error) {
if (error == OK)
return "OK";
const char* error_string;
switch (error) {
#define NET_ERROR(label, value) \
case ERR_ ## label: \
error_string = # label; \
break;
#include "net/base/net_error_list.h"
#undef NET_ERROR
default:
// TODO(crbug.com/1439949): Figure out why this is firing, fix and upgrade
// this to be fatal.
DUMP_WILL_BE_NOTREACHED_NORETURN() << error;
error_string = "<unknown>";
}
return std::string("ERR_") + error_string;
}
bool IsCertificateError(int error) {
// Certificate errors are negative integers from net::ERR_CERT_BEGIN
// (inclusive) to net::ERR_CERT_END (exclusive) in *decreasing* order.
// ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN is currently an exception to this
// rule.
return (error <= ERR_CERT_BEGIN && error > ERR_CERT_END) ||
(error == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN);
}
bool IsClientCertificateError(int error) {
switch (error) {
case ERR_BAD_SSL_CLIENT_AUTH_CERT:
case ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED:
case ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY:
case ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED:
case ERR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS:
return true;
default:
return false;
}
}
bool IsHostnameResolutionError(int error) {
DCHECK_NE(ERR_NAME_RESOLUTION_FAILED, error);
return error == ERR_NAME_NOT_RESOLVED;
}
bool IsRequestBlockedError(int error) {
switch (error) {
case ERR_BLOCKED_BY_CLIENT:
case ERR_BLOCKED_BY_ADMINISTRATOR:
case ERR_BLOCKED_BY_CSP:
return true;
default:
return false;
}
}
Error FileErrorToNetError(base::File::Error file_error) {
switch (file_error) {
case base::File::FILE_OK:
return OK;
case base::File::FILE_ERROR_EXISTS:
return ERR_FILE_EXISTS;
case base::File::FILE_ERROR_NOT_FOUND:
return ERR_FILE_NOT_FOUND;
case base::File::FILE_ERROR_ACCESS_DENIED:
return ERR_ACCESS_DENIED;
case base::File::FILE_ERROR_NO_MEMORY:
return ERR_OUT_OF_MEMORY;
case base::File::FILE_ERROR_NO_SPACE:
return ERR_FILE_NO_SPACE;
case base::File::FILE_ERROR_INVALID_OPERATION:
return ERR_INVALID_ARGUMENT;
case base::File::FILE_ERROR_ABORT:
return ERR_ABORTED;
case base::File::FILE_ERROR_INVALID_URL:
return ERR_INVALID_URL;
case base::File::FILE_ERROR_TOO_MANY_OPENED:
return ERR_INSUFFICIENT_RESOURCES;
case base::File::FILE_ERROR_SECURITY:
return ERR_ACCESS_DENIED;
case base::File::FILE_ERROR_MAX:
NOTREACHED();
[[fallthrough]];
case base::File::FILE_ERROR_NOT_A_DIRECTORY:
case base::File::FILE_ERROR_NOT_A_FILE:
case base::File::FILE_ERROR_NOT_EMPTY:
case base::File::FILE_ERROR_IO:
case base::File::FILE_ERROR_IN_USE:
// No good mappings for these, so just fallthrough to generic fail.
case base::File::FILE_ERROR_FAILED:
return ERR_FAILED;
}
NOTREACHED();
return ERR_FAILED;
}
} // namespace net
|
