blob: 553c0bd6a3995e3666df74a364ce41eb53da7dca (
plain)
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
|
#include "http2/adapter/http2_util.h"
#include "spdy/core/spdy_protocol.h"
namespace http2 {
namespace adapter {
namespace {
using ConnectionError = Http2VisitorInterface::ConnectionError;
using InvalidFrameError = Http2VisitorInterface::InvalidFrameError;
} // anonymous namespace
spdy::SpdyErrorCode TranslateErrorCode(Http2ErrorCode code) {
switch (code) {
case Http2ErrorCode::HTTP2_NO_ERROR:
return spdy::ERROR_CODE_NO_ERROR;
case Http2ErrorCode::PROTOCOL_ERROR:
return spdy::ERROR_CODE_PROTOCOL_ERROR;
case Http2ErrorCode::INTERNAL_ERROR:
return spdy::ERROR_CODE_INTERNAL_ERROR;
case Http2ErrorCode::FLOW_CONTROL_ERROR:
return spdy::ERROR_CODE_FLOW_CONTROL_ERROR;
case Http2ErrorCode::SETTINGS_TIMEOUT:
return spdy::ERROR_CODE_SETTINGS_TIMEOUT;
case Http2ErrorCode::STREAM_CLOSED:
return spdy::ERROR_CODE_STREAM_CLOSED;
case Http2ErrorCode::FRAME_SIZE_ERROR:
return spdy::ERROR_CODE_FRAME_SIZE_ERROR;
case Http2ErrorCode::REFUSED_STREAM:
return spdy::ERROR_CODE_REFUSED_STREAM;
case Http2ErrorCode::CANCEL:
return spdy::ERROR_CODE_CANCEL;
case Http2ErrorCode::COMPRESSION_ERROR:
return spdy::ERROR_CODE_COMPRESSION_ERROR;
case Http2ErrorCode::CONNECT_ERROR:
return spdy::ERROR_CODE_CONNECT_ERROR;
case Http2ErrorCode::ENHANCE_YOUR_CALM:
return spdy::ERROR_CODE_ENHANCE_YOUR_CALM;
case Http2ErrorCode::INADEQUATE_SECURITY:
return spdy::ERROR_CODE_INADEQUATE_SECURITY;
case Http2ErrorCode::HTTP_1_1_REQUIRED:
return spdy::ERROR_CODE_HTTP_1_1_REQUIRED;
}
return spdy::ERROR_CODE_INTERNAL_ERROR;
}
Http2ErrorCode TranslateErrorCode(spdy::SpdyErrorCode code) {
switch (code) {
case spdy::ERROR_CODE_NO_ERROR:
return Http2ErrorCode::HTTP2_NO_ERROR;
case spdy::ERROR_CODE_PROTOCOL_ERROR:
return Http2ErrorCode::PROTOCOL_ERROR;
case spdy::ERROR_CODE_INTERNAL_ERROR:
return Http2ErrorCode::INTERNAL_ERROR;
case spdy::ERROR_CODE_FLOW_CONTROL_ERROR:
return Http2ErrorCode::FLOW_CONTROL_ERROR;
case spdy::ERROR_CODE_SETTINGS_TIMEOUT:
return Http2ErrorCode::SETTINGS_TIMEOUT;
case spdy::ERROR_CODE_STREAM_CLOSED:
return Http2ErrorCode::STREAM_CLOSED;
case spdy::ERROR_CODE_FRAME_SIZE_ERROR:
return Http2ErrorCode::FRAME_SIZE_ERROR;
case spdy::ERROR_CODE_REFUSED_STREAM:
return Http2ErrorCode::REFUSED_STREAM;
case spdy::ERROR_CODE_CANCEL:
return Http2ErrorCode::CANCEL;
case spdy::ERROR_CODE_COMPRESSION_ERROR:
return Http2ErrorCode::COMPRESSION_ERROR;
case spdy::ERROR_CODE_CONNECT_ERROR:
return Http2ErrorCode::CONNECT_ERROR;
case spdy::ERROR_CODE_ENHANCE_YOUR_CALM:
return Http2ErrorCode::ENHANCE_YOUR_CALM;
case spdy::ERROR_CODE_INADEQUATE_SECURITY:
return Http2ErrorCode::INADEQUATE_SECURITY;
case spdy::ERROR_CODE_HTTP_1_1_REQUIRED:
return Http2ErrorCode::HTTP_1_1_REQUIRED;
}
return Http2ErrorCode::INTERNAL_ERROR;
}
absl::string_view ConnectionErrorToString(ConnectionError error) {
switch (error) {
case ConnectionError::kInvalidConnectionPreface:
return "InvalidConnectionPreface";
case ConnectionError::kSendError:
return "SendError";
case ConnectionError::kParseError:
return "ParseError";
case ConnectionError::kHeaderError:
return "HeaderError";
case ConnectionError::kInvalidNewStreamId:
return "InvalidNewStreamId";
case ConnectionError::kWrongFrameSequence:
return "kWrongFrameSequence";
case ConnectionError::kInvalidPushPromise:
return "InvalidPushPromise";
case ConnectionError::kExceededMaxConcurrentStreams:
return "ExceededMaxConcurrentStreams";
}
return "UnknownConnectionError";
}
absl::string_view InvalidFrameErrorToString(
Http2VisitorInterface::InvalidFrameError error) {
switch (error) {
case InvalidFrameError::kProtocol:
return "Protocol";
case InvalidFrameError::kRefusedStream:
return "RefusedStream";
case InvalidFrameError::kHttpHeader:
return "HttpHeader";
case InvalidFrameError::kHttpMessaging:
return "HttpMessaging";
case InvalidFrameError::kFlowControl:
return "FlowControl";
case InvalidFrameError::kStreamClosed:
return "StreamClosed";
}
return "UnknownInvalidFrameError";
}
} // namespace adapter
} // namespace http2
|
