1 // Copyright 2016 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 #include "quiche/http2/http2_constants.h"
6
7 #include "absl/strings/str_cat.h"
8 #include "absl/strings/str_format.h"
9 #include "absl/strings/string_view.h"
10 #include "quiche/common/platform/api/quiche_logging.h"
11
12 namespace http2 {
13
Http2FrameTypeToString(Http2FrameType v)14 std::string Http2FrameTypeToString(Http2FrameType v) {
15 switch (v) {
16 case Http2FrameType::DATA:
17 return "DATA";
18 case Http2FrameType::HEADERS:
19 return "HEADERS";
20 case Http2FrameType::PRIORITY:
21 return "PRIORITY";
22 case Http2FrameType::RST_STREAM:
23 return "RST_STREAM";
24 case Http2FrameType::SETTINGS:
25 return "SETTINGS";
26 case Http2FrameType::PUSH_PROMISE:
27 return "PUSH_PROMISE";
28 case Http2FrameType::PING:
29 return "PING";
30 case Http2FrameType::GOAWAY:
31 return "GOAWAY";
32 case Http2FrameType::WINDOW_UPDATE:
33 return "WINDOW_UPDATE";
34 case Http2FrameType::CONTINUATION:
35 return "CONTINUATION";
36 case Http2FrameType::ALTSVC:
37 return "ALTSVC";
38 case Http2FrameType::PRIORITY_UPDATE:
39 return "PRIORITY_UPDATE";
40 }
41 return absl::StrCat("UnknownFrameType(", static_cast<int>(v), ")");
42 }
43
Http2FrameTypeToString(uint8_t v)44 std::string Http2FrameTypeToString(uint8_t v) {
45 return Http2FrameTypeToString(static_cast<Http2FrameType>(v));
46 }
47
Http2FrameFlagsToString(Http2FrameType type,uint8_t flags)48 std::string Http2FrameFlagsToString(Http2FrameType type, uint8_t flags) {
49 std::string s;
50 // Closure to append flag name |v| to the std::string |s|,
51 // and to clear |bit| from |flags|.
52 auto append_and_clear = [&s, &flags](absl::string_view v, uint8_t bit) {
53 if (!s.empty()) {
54 s.push_back('|');
55 }
56 absl::StrAppend(&s, v);
57 flags ^= bit;
58 };
59 if (flags & 0x01) {
60 if (type == Http2FrameType::DATA || type == Http2FrameType::HEADERS) {
61 append_and_clear("END_STREAM", Http2FrameFlag::END_STREAM);
62 } else if (type == Http2FrameType::SETTINGS ||
63 type == Http2FrameType::PING) {
64 append_and_clear("ACK", Http2FrameFlag::ACK);
65 }
66 }
67 if (flags & 0x04) {
68 if (type == Http2FrameType::HEADERS ||
69 type == Http2FrameType::PUSH_PROMISE ||
70 type == Http2FrameType::CONTINUATION) {
71 append_and_clear("END_HEADERS", Http2FrameFlag::END_HEADERS);
72 }
73 }
74 if (flags & 0x08) {
75 if (type == Http2FrameType::DATA || type == Http2FrameType::HEADERS ||
76 type == Http2FrameType::PUSH_PROMISE) {
77 append_and_clear("PADDED", Http2FrameFlag::PADDED);
78 }
79 }
80 if (flags & 0x20) {
81 if (type == Http2FrameType::HEADERS) {
82 append_and_clear("PRIORITY", Http2FrameFlag::PRIORITY);
83 }
84 }
85 if (flags != 0) {
86 append_and_clear(absl::StrFormat("0x%02x", flags), flags);
87 }
88 QUICHE_DCHECK_EQ(0, flags);
89 return s;
90 }
Http2FrameFlagsToString(uint8_t type,uint8_t flags)91 std::string Http2FrameFlagsToString(uint8_t type, uint8_t flags) {
92 return Http2FrameFlagsToString(static_cast<Http2FrameType>(type), flags);
93 }
94
Http2ErrorCodeToString(uint32_t v)95 std::string Http2ErrorCodeToString(uint32_t v) {
96 switch (v) {
97 case 0x0:
98 return "NO_ERROR";
99 case 0x1:
100 return "PROTOCOL_ERROR";
101 case 0x2:
102 return "INTERNAL_ERROR";
103 case 0x3:
104 return "FLOW_CONTROL_ERROR";
105 case 0x4:
106 return "SETTINGS_TIMEOUT";
107 case 0x5:
108 return "STREAM_CLOSED";
109 case 0x6:
110 return "FRAME_SIZE_ERROR";
111 case 0x7:
112 return "REFUSED_STREAM";
113 case 0x8:
114 return "CANCEL";
115 case 0x9:
116 return "COMPRESSION_ERROR";
117 case 0xa:
118 return "CONNECT_ERROR";
119 case 0xb:
120 return "ENHANCE_YOUR_CALM";
121 case 0xc:
122 return "INADEQUATE_SECURITY";
123 case 0xd:
124 return "HTTP_1_1_REQUIRED";
125 }
126 return absl::StrCat("UnknownErrorCode(0x", absl::Hex(v), ")");
127 }
Http2ErrorCodeToString(Http2ErrorCode v)128 std::string Http2ErrorCodeToString(Http2ErrorCode v) {
129 return Http2ErrorCodeToString(static_cast<uint32_t>(v));
130 }
131
Http2SettingsParameterToString(uint32_t v)132 std::string Http2SettingsParameterToString(uint32_t v) {
133 switch (v) {
134 case 0x1:
135 return "HEADER_TABLE_SIZE";
136 case 0x2:
137 return "ENABLE_PUSH";
138 case 0x3:
139 return "MAX_CONCURRENT_STREAMS";
140 case 0x4:
141 return "INITIAL_WINDOW_SIZE";
142 case 0x5:
143 return "MAX_FRAME_SIZE";
144 case 0x6:
145 return "MAX_HEADER_LIST_SIZE";
146 }
147 return absl::StrCat("UnknownSettingsParameter(0x", absl::Hex(v), ")");
148 }
Http2SettingsParameterToString(Http2SettingsParameter v)149 std::string Http2SettingsParameterToString(Http2SettingsParameter v) {
150 return Http2SettingsParameterToString(static_cast<uint32_t>(v));
151 }
152
153 // Invalid HTTP/2 header names according to
154 // https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.2.
155 // TODO(b/78024822): Consider adding "upgrade" to this set.
156 constexpr char const* kHttp2InvalidHeaderNames[] = {
157 "connection", "host", "keep-alive", "proxy-connection",
158 "transfer-encoding", "",
159 };
160
GetInvalidHttp2HeaderSet()161 const InvalidHeaderSet& GetInvalidHttp2HeaderSet() {
162 static const auto* invalid_header_set =
163 new InvalidHeaderSet(std::begin(http2::kHttp2InvalidHeaderNames),
164 std::end(http2::kHttp2InvalidHeaderNames));
165 return *invalid_header_set;
166 }
167
168 } // namespace http2
169